src/node/APTRepositories.js

   1 Ext.define('apt-repolist', {
   2     extend: 'Ext.data.Model',
   3     fields: [
   4         'Path',
   5         'Index',
   6         'Origin',
   7         'FileType',
   8         'Enabled',
   9         'Comment',
  10         'Types',
  11         'URIs',
  12         'Suites',
  13         'Components',
  14         'Options',
  15     ],
  16 });
  17
  18 Ext.define('Proxmox.window.APTRepositoryAdd', {
  19     extend: 'Proxmox.window.Edit',
  20     alias: 'widget.pmxAPTRepositoryAdd',
  21
  22     isCreate: true,
  23     isAdd: true,
  24
  25     subject: gettext('Repository'),
  26     width: 600,
  27
  28     initComponent: function() {
  29         let me = this;
  30
  31         if (!me.repoInfo || me.repoInfo.length === 0) {
  32             throw "repository information not initialized";
  33         }
  34
  35         let description = Ext.create('Ext.form.field.Display', {
  36             fieldLabel: gettext('Description'),
  37             name: 'description',
  38         });
  39
  40         let status = Ext.create('Ext.form.field.Display', {
  41             fieldLabel: gettext('Status'),
  42             name: 'status',
  43             renderer: function(value) {
  44                 let statusText = gettext('Not yet configured');
  45                 if (value !== '') {
  46                     statusText = Ext.String.format(
  47                         '{0}: {1}',
  48                         gettext('Configured'),
  49                         value ? gettext('enabled') : gettext('disabled'),
  50                     );
  51                 }
  52
  53                 return statusText;
  54             },
  55         });
  56
  57         let repoSelector = Ext.create('Proxmox.form.KVComboBox', {
  58             fieldLabel: gettext('Repository'),
  59             xtype: 'proxmoxKVComboBox',
  60             name: 'handle',
  61             allowBlank: false,
  62             comboItems: me.repoInfo.map(info => [info.handle, info.name]),
  63             validator: function(renderedValue) {
  64                 let handle = this.value;
  65                 // we cannot use this.callParent in instantiations
  66                 let valid = Proxmox.form.KVComboBox.prototype.validator.call(this, renderedValue);
  67
  68                 if (!valid || !handle) {
  69                     return false;
  70                 }
  71
  72                 const info = me.repoInfo.find(elem => elem.handle === handle);
  73                 if (!info) {
  74                     return false;
  75                 }
  76
  77                 if (info.status) {
  78                     return Ext.String.format(gettext('{0} is already configured'), renderedValue);
  79                 }
  80                 return valid;
  81             },
  82             listeners: {
  83                 change: function(f, value) {
  84                     const info = me.repoInfo.find(elem => elem.handle === value);
  85                     description.setValue(info.description);
  86                     status.setValue(info.status);
  87                 },
  88             },
  89         });
  90
  91         repoSelector.setValue(me.repoInfo[0].handle);
  92
  93         Ext.apply(me, {
  94             items: [
  95                 repoSelector,
  96                 description,
  97                 status,
  98             ],
  99             repoSelector: repoSelector,
 100         });
 101
 102         me.callParent();
 103     },
 104 });
 105
 106 Ext.define('Proxmox.node.APTRepositoriesErrors', {
 107     extend: 'Ext.grid.GridPanel',
 108
 109     xtype: 'proxmoxNodeAPTRepositoriesErrors',
 110
 111     store: {},
 112
 113     scrollable: true,
 114
 115     viewConfig: {
 116         stripeRows: false,
 117         getRowClass: (record) => {
 118             switch (record.data.status) {
 119                 case 'warning': return 'proxmox-warning-row';
 120                 case 'critical': return 'proxmox-invalid-row';
 121                 default: return '';
 122             }
 123         },
 124     },
 125
 126     hideHeaders: true,
 127
 128     columns: [
 129         {
 130             dataIndex: 'status',
 131             renderer: (value) => `<i class="fa fa-fw ${Proxmox.Utils.get_health_icon(value, true)}"></i>`,
 132             width: 50,
 133         },
 134         {
 135             dataIndex: 'message',
 136             flex: 1,
 137         },
 138     ],
 139 });
 140
 141 Ext.define('Proxmox.node.APTRepositoriesGrid', {
 142     extend: 'Ext.grid.GridPanel',
 143     xtype: 'proxmoxNodeAPTRepositoriesGrid',
 144     mixins: ['Proxmox.Mixin.CBind'],
 145
 146     title: gettext('APT Repositories'),
 147
 148     cls: 'proxmox-apt-repos', // to allow applying styling to general components with local effect
 149
 150     border: false,
 151
 152     tbar: [
 153         {
 154             text: gettext('Reload'),
 155             iconCls: 'fa fa-refresh',
 156             handler: function() {
 157                 let me = this;
 158                 me.up('proxmoxNodeAPTRepositories').reload();
 159             },
 160         },
 161         {
 162             text: gettext('Add'),
 163             name: 'addRepo',
 164             disabled: true,
 165             repoInfo: undefined,
 166             cbind: {
 167                 onlineHelp: '{onlineHelp}',
 168             },
 169             handler: function(button, event, record) {
 170                 Proxmox.Utils.checked_command(() => {
 171                     let me = this;
 172                     let panel = me.up('proxmoxNodeAPTRepositories');
 173
 174                     let extraParams = {};
 175                     if (panel.digest !== undefined) {
 176                        extraParams.digest = panel.digest;
 177                     }
 178
 179                     Ext.create('Proxmox.window.APTRepositoryAdd', {
 180                         repoInfo: me.repoInfo,
 181                         url: `/api2/extjs/nodes/${panel.nodename}/apt/repositories`,
 182                         method: 'PUT',
 183                         extraRequestParams: extraParams,
 184                         onlineHelp: me.onlineHelp,
 185                         listeners: {
 186                             destroy: function() {
 187                                 panel.reload();
 188                             },
 189                         },
 190                     }).show();
 191                 });
 192             },
 193         },
 194         '-',
 195         {
 196             xtype: 'proxmoxAltTextButton',
 197             defaultText: gettext('Enable'),
 198             altText: gettext('Disable'),
 199             name: 'repoEnable',
 200             disabled: true,
 201             bind: {
 202                 text: '{enableButtonText}',
 203             },
 204             handler: function(button, event, record) {
 205                 let me = this;
 206                 let panel = me.up('proxmoxNodeAPTRepositories');
 207
 208                 let params = {
 209                     path: record.data.Path,
 210                     index: record.data.Index,
 211                     enabled: record.data.Enabled ? 0 : 1, // invert
 212                 };
 213
 214                 if (panel.digest !== undefined) {
 215                    params.digest = panel.digest;
 216                 }
 217
 218                 Proxmox.Utils.API2Request({
 219                     url: `/nodes/${panel.nodename}/apt/repositories`,
 220                     method: 'POST',
 221                     params: params,
 222                     failure: function(response, opts) {
 223                         Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 224                         panel.reload();
 225                     },
 226                     success: function(response, opts) {
 227                         panel.reload();
 228                     },
 229                 });
 230             },
 231         },
 232     ],
 233
 234     sortableColumns: false,
 235     viewConfig: {
 236         stripeRows: false,
 237         getRowClass: (record, index) => record.get('Enabled') ? '' : 'proxmox-disabled-row',
 238     },
 239
 240     columns: [
 241         {
 242             header: gettext('Enabled'),
 243             dataIndex: 'Enabled',
 244             align: 'center',
 245             renderer: Proxmox.Utils.renderEnabledIcon,
 246             width: 90,
 247         },
 248         {
 249             header: gettext('Types'),
 250             dataIndex: 'Types',
 251             renderer: function(types, cell, record) {
 252                 return types.join(' ');
 253             },
 254             width: 100,
 255         },
 256         {
 257             header: gettext('URIs'),
 258             dataIndex: 'URIs',
 259             renderer: function(uris, cell, record) {
 260                 return uris.join(' ');
 261             },
 262             width: 350,
 263         },
 264         {
 265             header: gettext('Suites'),
 266             dataIndex: 'Suites',
 267             renderer: function(suites, metaData, record) {
 268                 let err = '';
 269                 if (record.data.warnings && record.data.warnings.length > 0) {
 270                     let txt = [gettext('Warning')];
 271                     record.data.warnings.forEach((warning) => {
 272                         if (warning.property === 'Suites') {
 273                             txt.push(warning.message);
 274                         }
 275                     });
 276                     metaData.tdAttr = `data-qtip="${Ext.htmlEncode(txt.join('<br>'))}"`;
 277                     if (record.data.Enabled) {
 278                         metaData.tdCls = 'proxmox-invalid-row';
 279                         err = '<i class="fa fa-fw critical fa-exclamation-circle"></i> ';
 280                     } else {
 281                         metaData.tdCls = 'proxmox-warning-row';
 282                         err = '<i class="fa fa-fw warning fa-exclamation-circle"></i> ';
 283                     }
 284                 }
 285                 return suites.join(' ') + err;
 286             },
 287             width: 130,
 288         },
 289         {
 290             header: gettext('Components'),
 291             dataIndex: 'Components',
 292             renderer: function(components, metaData, record) {
 293                 if (components === undefined) {
 294                     return '';
 295                 }
 296                 let err = '';
 297                 if (components.length === 1) {
 298                     // FIXME: this should be a flag set to the actual repsotiories, i.e., a tristate
 299                     // like production-ready = <yes|no|other> (Option<bool>)
 300                     if (components[0].match(/\w+(-no-subscription|test)\s*$/i)) {
 301                         metaData.tdCls = 'proxmox-warning-row';
 302                         err = '<i class="fa fa-fw warning fa-exclamation-circle"></i> ';
 303
 304                         let qtip = components[0].match(/no-subscription/)
 305                             ? gettext('The no-subscription repository is NOT production-ready')
 306                             : gettext('The test repository may contain unstable updates')
 307                             ;
 308                             metaData.tdAttr = `data-qtip="${Ext.htmlEncode(qtip)}"`;
 309                     }
 310                 }
 311                 return components.join(' ') + err;
 312             },
 313             width: 170,
 314         },
 315         {
 316             header: gettext('Options'),
 317             dataIndex: 'Options',
 318             renderer: function(options, cell, record) {
 319                 if (!options) {
 320                     return '';
 321                 }
 322
 323                 let filetype = record.data.FileType;
 324                 let text = '';
 325
 326                 options.forEach(function(option) {
 327                     let key = option.Key;
 328                     if (filetype === 'list') {
 329                         let values = option.Values.join(',');
 330                         text += `${key}=${values} `;
 331                     } else if (filetype === 'sources') {
 332                         let values = option.Values.join(' ');
 333                         text += `${key}: ${values}<br>`;
 334                     } else {
 335                         throw "unknown file type";
 336                     }
 337                 });
 338                 return text;
 339             },
 340             flex: 1,
 341         },
 342         {
 343             header: gettext('Origin'),
 344             dataIndex: 'Origin',
 345             width: 120,
 346             renderer: function(value, meta, rec) {
 347                 if (typeof value !== 'string' || value.length === 0) {
 348                     value = gettext('Other');
 349                 }
 350                 let cls = 'fa fa-fw fa-question-circle-o';
 351                 let originType = this.up('proxmoxNodeAPTRepositories').classifyOrigin(value);
 352                 if (originType === 'Proxmox') {
 353                     cls = 'pmx-itype-icon pmx-itype-icon-proxmox-x';
 354                 } else if (originType === 'Debian') {
 355                     cls = 'pmx-itype-icon pmx-itype-icon-debian-swirl';
 356                 }
 357                 return `<i class='${cls}'></i> ${value}`;
 358             },
 359         },
 360         {
 361             header: gettext('Comment'),
 362             dataIndex: 'Comment',
 363             flex: 2,
 364             renderer: Ext.String.htmlEncode,
 365         },
 366     ],
 367
 368     features: [
 369         {
 370             ftype: 'grouping',
 371             groupHeaderTpl: '{[ "File: " + values.name ]} ({rows.length} repositor{[values.rows.length > 1 ? "ies" : "y"]})',
 372             enableGroupingMenu: false,
 373         },
 374     ],
 375
 376     store: {
 377         model: 'apt-repolist',
 378         groupField: 'Path',
 379         sorters: [
 380             {
 381                 property: 'Index',
 382                 direction: 'ASC',
 383             },
 384         ],
 385     },
 386
 387     initComponent: function() {
 388         let me = this;
 389
 390         if (!me.nodename) {
 391             throw "no node name specified";
 392         }
 393
 394         me.callParent();
 395     },
 396 });
 397
 398 Ext.define('Proxmox.node.APTRepositories', {
 399     extend: 'Ext.panel.Panel',
 400     xtype: 'proxmoxNodeAPTRepositories',
 401     mixins: ['Proxmox.Mixin.CBind'],
 402
 403     digest: undefined,
 404
 405     onlineHelp: undefined,
 406
 407     product: 'Proxmox VE', // default
 408
 409     classifyOrigin: function(origin) {
 410         origin ||= '';
 411         if (origin.match(/^\s*Proxmox\s*$/i)) {
 412             return 'Proxmox';
 413         } else if (origin.match(/^\s*Debian\s*(:?Backports)?$/i)) {
 414             return 'Debian';
 415         }
 416         return 'Other';
 417     },
 418
 419     controller: {
 420         xclass: 'Ext.app.ViewController',
 421
 422         selectionChange: function(grid, selection) {
 423             let me = this;
 424             if (!selection || selection.length < 1) {
 425                 return;
 426             }
 427             let rec = selection[0];
 428             let vm = me.getViewModel();
 429             vm.set('selectionenabled', rec.get('Enabled'));
 430             vm.notify();
 431         },
 432
 433         updateState: function() {
 434             let me = this;
 435             let vm = me.getViewModel();
 436
 437             let store = vm.get('errorstore');
 438             store.removeAll();
 439
 440             let status = 'good'; // start with best, the helper below will downgrade if needed
 441             let text = gettext('All OK, you have production-ready repositories configured!');
 442
 443             let addGood = message => store.add({ status: 'good', message });
 444             let addWarn = (message, important) => {
 445                 if (status !== 'critical') {
 446                     status = 'warning';
 447                     text = important ? message : gettext('Warning');
 448                 }
 449                 store.add({ status: 'warning', message });
 450             };
 451             let addCritical = (message, important) => {
 452                 status = 'critical';
 453                 text = important ? message : gettext('Error');
 454                 store.add({ status: 'critical', message });
 455             };
 456
 457             let errors = vm.get('errors');
 458             errors.forEach(error => addCritical(`${error.path} - ${error.error}`));
 459
 460             let activeSubscription = vm.get('subscriptionActive');
 461             let enterprise = vm.get('enterpriseRepo');
 462             let nosubscription = vm.get('noSubscriptionRepo');
 463             let test = vm.get('testRepo');
 464             let cephRepos = {
 465                 enterprise: vm.get('cephEnterpriseRepo'),
 466                 nosubscription: vm.get('cephNoSubscriptionRepo'),
 467                 test: vm.get('cephTestRepo'),
 468             };
 469             let wrongSuites = vm.get('suitesWarning');
 470             let mixedSuites = vm.get('mixedSuites');
 471
 472             if (!enterprise && !nosubscription && !test) {
 473                 addCritical(
 474                     Ext.String.format(gettext('No {0} repository is enabled, you do not get any updates!'), vm.get('product')),
 475                 );
 476             } else if (errors.length > 0) {
 477                 // nothing extra, just avoid that we show "get updates"
 478             } else if (enterprise && !nosubscription && !test && activeSubscription) {
 479                 addGood(Ext.String.format(gettext('You get supported updates for {0}'), vm.get('product')));
 480             } else if (nosubscription || test) {
 481                 addGood(Ext.String.format(gettext('You get updates for {0}'), vm.get('product')));
 482             }
 483
 484             if (wrongSuites) {
 485                 addWarn(gettext('Some suites are misconfigured'));
 486             }
 487
 488             if (mixedSuites) {
 489                 addWarn(gettext('Detected mixed suites before upgrade'));
 490             }
 491
 492             let productionReadyCheck = (repos, type, noSubAlternateName) => {
 493                 if (!activeSubscription && repos.enterprise) {
 494                     addWarn(Ext.String.format(
 495                         gettext('The {0}enterprise repository is enabled, but there is no active subscription!'),
 496                         type,
 497                     ));
 498                 }
 499
 500                 if (repos.nosubscription) {
 501                     addWarn(Ext.String.format(
 502                         gettext('The {0}no-subscription{1} repository is not recommended for production use!'),
 503                         type,
 504                         noSubAlternateName,
 505                     ));
 506                 }
 507
 508                 if (repos.test) {
 509                     addWarn(Ext.String.format(
 510                         gettext('The {0}test repository may pull in unstable updates and is not recommended for production use!'),
 511                         type,
 512                     ));
 513                 }
 514             };
 515
 516             productionReadyCheck({ enterprise, nosubscription, test }, '', '');
 517             // TODO drop alternate 'main' name when no longer relevant
 518             productionReadyCheck(cephRepos, 'Ceph ', '/main');
 519
 520             if (errors.length > 0) {
 521                 text = gettext('Fatal parsing error for at least one repository');
 522             }
 523
 524             let iconCls = Proxmox.Utils.get_health_icon(status, true);
 525
 526             vm.set('state', {
 527                 iconCls,
 528                 text,
 529             });
 530         },
 531     },
 532
 533     viewModel: {
 534         data: {
 535             product: 'Proxmox VE', // default
 536             errors: [],
 537             suitesWarning: false,
 538             mixedSuites: false, // used before major upgrade
 539             subscriptionActive: '',
 540             noSubscriptionRepo: '',
 541             enterpriseRepo: '',
 542             testRepo: '',
 543             cephEnterpriseRepo: '',
 544             cephNoSubscriptionRepo: '',
 545             cephTestRepo: '',
 546             selectionenabled: false,
 547             state: {},
 548         },
 549         formulas: {
 550             enableButtonText: (get) => get('selectionenabled')
 551                 ? gettext('Disable') : gettext('Enable'),
 552         },
 553         stores: {
 554             errorstore: {
 555                 fields: ['status', 'message'],
 556             },
 557         },
 558     },
 559
 560     scrollable: true,
 561     layout: {
 562         type: 'vbox',
 563         align: 'stretch',
 564     },
 565
 566     items: [
 567         {
 568             xtype: 'panel',
 569             border: false,
 570             layout: {
 571                 type: 'hbox',
 572                 align: 'stretch',
 573             },
 574             height: 200,
 575             title: gettext('Status'),
 576             items: [
 577                 {
 578                     xtype: 'box',
 579                     flex: 2,
 580                     margin: 10,
 581                     data: {
 582                         iconCls: Proxmox.Utils.get_health_icon(undefined, true),
 583                         text: '',
 584                     },
 585                     bind: {
 586                         data: '{state}',
 587                     },
 588                     tpl: [
 589                         '<center class="centered-flex-column" style="font-size:15px;line-height: 25px;">',
 590                         '<i class="fa fa-4x {iconCls}"></i>',
 591                         '{text}',
 592                         '</center>',
 593                     ],
 594                 },
 595                 {
 596                     xtype: 'proxmoxNodeAPTRepositoriesErrors',
 597                     name: 'repositoriesErrors',
 598                     flex: 7,
 599                     margin: 10,
 600                     bind: {
 601                         store: '{errorstore}',
 602                     },
 603                 },
 604             ],
 605         },
 606         {
 607             xtype: 'proxmoxNodeAPTRepositoriesGrid',
 608             name: 'repositoriesGrid',
 609             flex: 1,
 610             cbind: {
 611                 nodename: '{nodename}',
 612                 onlineHelp: '{onlineHelp}',
 613             },
 614             majorUpgradeAllowed: false, // TODO get release information from an API call?
 615             listeners: {
 616                 selectionchange: 'selectionChange',
 617             },
 618         },
 619     ],
 620
 621     check_subscription: function() {
 622         let me = this;
 623         let vm = me.getViewModel();
 624
 625         Proxmox.Utils.API2Request({
 626             url: `/nodes/${me.nodename}/subscription`,
 627             method: 'GET',
 628             failure: (response, opts) => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
 629             success: function(response, opts) {
 630                 const res = response.result;
 631                 const subscription = !(!res || !res.data || res.data.status.toLowerCase() !== 'active');
 632                 vm.set('subscriptionActive', subscription);
 633                 me.getController().updateState();
 634             },
 635         });
 636     },
 637
 638     updateStandardRepos: function(standardRepos) {
 639         let me = this;
 640         let vm = me.getViewModel();
 641
 642         let addButton = me.down('button[name=addRepo]');
 643
 644         addButton.repoInfo = [];
 645         for (const standardRepo of standardRepos) {
 646             const handle = standardRepo.handle;
 647             const status = standardRepo.status;
 648
 649             if (handle === "enterprise") {
 650                 vm.set('enterpriseRepo', status);
 651             } else if (handle === "no-subscription") {
 652                 vm.set('noSubscriptionRepo', status);
 653             } else if (handle === 'test') {
 654                 vm.set('testRepo', status);
 655             } else if (handle.match(/^ceph-[a-zA-Z]+-enterprise$/)) {
 656                 vm.set('cephEnterpriseRepo', status);
 657             } else if (handle.match(/^ceph-[a-zA-Z]+-no-subscription$/)) {
 658                 vm.set('cephNoSubscriptionRepo', status);
 659             } else if (handle.match(/^ceph-[a-zA-Z]+-test$/)) {
 660                 vm.set('cephTestRepo', status);
 661             }
 662             me.getController().updateState();
 663
 664             addButton.repoInfo.push(standardRepo);
 665             addButton.digest = me.digest;
 666         }
 667
 668         addButton.setDisabled(false);
 669     },
 670
 671     reload: function() {
 672         let me = this;
 673         let vm = me.getViewModel();
 674         let repoGrid = me.down('proxmoxNodeAPTRepositoriesGrid');
 675
 676         me.store.load(function(records, operation, success) {
 677             let gridData = [];
 678             let errors = [];
 679             let digest;
 680             let suitesWarning = false;
 681
 682             // Usually different suites will give errors anyways, but before a major upgrade the
 683             // current and the next suite are allowed, so it makes sense to check for mixed suites.
 684             let checkMixedSuites = false;
 685             let mixedSuites = false;
 686
 687             if (success && records.length > 0) {
 688                 let data = records[0].data;
 689                 let files = data.files;
 690                 errors = data.errors;
 691                 digest = data.digest;
 692
 693                 let infos = {};
 694                 for (const info of data.infos) {
 695                     let path = info.path;
 696                     let idx = info.index;
 697
 698                     if (!infos[path]) {
 699                         infos[path] = {};
 700                     }
 701                     if (!infos[path][idx]) {
 702                         infos[path][idx] = {
 703                             origin: '',
 704                             warnings: [],
 705                             // Used as a heuristic to detect mixed repositories pre-upgrade. The
 706                             // warning is set on all repositories that do configure the next suite.
 707                             gotIgnorePreUpgradeWarning: false,
 708                         };
 709                     }
 710
 711                     if (info.kind === 'origin') {
 712                         infos[path][idx].origin = info.message;
 713                     } else if (info.kind === 'warning') {
 714                         infos[path][idx].warnings.push(info);
 715                     } else if (info.kind === 'ignore-pre-upgrade-warning') {
 716                         infos[path][idx].gotIgnorePreUpgradeWarning = true;
 717                         if (!repoGrid.majorUpgradeAllowed) {
 718                             infos[path][idx].warnings.push(info);
 719                         } else {
 720                             checkMixedSuites = true;
 721                         }
 722                     }
 723                 }
 724
 725
 726                 files.forEach(function(file) {
 727                     for (let n = 0; n < file.repositories.length; n++) {
 728                         let repo = file.repositories[n];
 729                         repo.Path = file.path;
 730                         repo.Index = n;
 731                         if (infos[file.path] && infos[file.path][n]) {
 732                             repo.Origin = infos[file.path][n].origin || Proxmox.Utils.unknownText;
 733                             repo.warnings = infos[file.path][n].warnings || [];
 734
 735                             if (repo.Enabled) {
 736                                 if (repo.warnings.some(w => w.property === 'Suites')) {
 737                                     suitesWarning = true;
 738                                 }
 739
 740                                 let originType = me.classifyOrigin(repo.Origin);
 741                                 // Only Proxmox and Debian repositories checked here, because the
 742                                 // warning can be missing for others for a different reason (e.g.
 743                                 // using 'stable' or non-Debian code names).
 744                                 if (checkMixedSuites && repo.Types.includes('deb') &&
 745                                     (originType === 'Proxmox' || originType === 'Debian') &&
 746                                     !infos[file.path][n].gotIgnorePreUpgradeWarning
 747                                 ) {
 748                                     mixedSuites = true;
 749                                 }
 750                             }
 751                         }
 752                         gridData.push(repo);
 753                     }
 754                 });
 755
 756                 repoGrid.store.loadData(gridData);
 757
 758                 me.updateStandardRepos(data['standard-repos']);
 759             }
 760
 761             me.digest = digest;
 762
 763             vm.set('errors', errors);
 764             vm.set('suitesWarning', suitesWarning);
 765             vm.set('mixedSuites', mixedSuites);
 766             me.getController().updateState();
 767         });
 768
 769         me.check_subscription();
 770     },
 771
 772     listeners: {
 773         activate: function() {
 774             let me = this;
 775             me.reload();
 776         },
 777     },
 778
 779     initComponent: function() {
 780         let me = this;
 781
 782         if (!me.nodename) {
 783             throw "no node name specified";
 784         }
 785
 786         let store = Ext.create('Ext.data.Store', {
 787             proxy: {
 788                 type: 'proxmox',
 789                 url: `/api2/json/nodes/${me.nodename}/apt/repositories`,
 790             },
 791         });
 792
 793         Ext.apply(me, { store: store });
 794
 795         Proxmox.Utils.monStoreErrors(me, me.store, true);
 796
 797         me.callParent();
 798
 799         me.getViewModel().set('product', me.product);
 800     },
 801 });