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
 145     title: gettext('APT Repositories'),
 146
 147     cls: 'proxmox-apt-repos', // to allow applying styling to general components with local effect
 148
 149     border: false,
 150
 151     tbar: [
 152         {
 153             text: gettext('Reload'),
 154             iconCls: 'fa fa-refresh',
 155             handler: function() {
 156                 let me = this;
 157                 me.up('proxmoxNodeAPTRepositories').reload();
 158             },
 159         },
 160         {
 161             text: gettext('Add'),
 162             name: 'addRepo',
 163             disabled: true,
 164             repoInfo: undefined,
 165             handler: function(button, event, record) {
 166                 Proxmox.Utils.checked_command(() => {
 167                     let me = this;
 168                     let panel = me.up('proxmoxNodeAPTRepositories');
 169
 170                     let extraParams = {};
 171                     if (panel.digest !== undefined) {
 172                        extraParams.digest = panel.digest;
 173                     }
 174
 175                     Ext.create('Proxmox.window.APTRepositoryAdd', {
 176                         repoInfo: me.repoInfo,
 177                         url: `/api2/extjs/nodes/${panel.nodename}/apt/repositories`,
 178                         method: 'PUT',
 179                         extraRequestParams: extraParams,
 180                         listeners: {
 181                             destroy: function() {
 182                                 panel.reload();
 183                             },
 184                         },
 185                     }).show();
 186                 });
 187             },
 188         },
 189         '-',
 190         {
 191             xtype: 'proxmoxButton',
 192             text: gettext('Enable'),
 193             defaultText: gettext('Enable'),
 194             altText: gettext('Disable'),
 195             name: 'repoEnable',
 196             disabled: true,
 197             bind: {
 198                 text: '{enableButtonText}',
 199             },
 200             handler: function(button, event, record) {
 201                 let me = this;
 202                 let panel = me.up('proxmoxNodeAPTRepositories');
 203
 204                 let params = {
 205                     path: record.data.Path,
 206                     index: record.data.Index,
 207                     enabled: record.data.Enabled ? 0 : 1, // invert
 208                 };
 209
 210                 if (panel.digest !== undefined) {
 211                    params.digest = panel.digest;
 212                 }
 213
 214                 Proxmox.Utils.API2Request({
 215                     url: `/nodes/${panel.nodename}/apt/repositories`,
 216                     method: 'POST',
 217                     params: params,
 218                     failure: function(response, opts) {
 219                         Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 220                         panel.reload();
 221                     },
 222                     success: function(response, opts) {
 223                         panel.reload();
 224                     },
 225                 });
 226             },
 227             listeners: {
 228                 render: function(btn) {
 229                     // HACK: calculate the max button width on first render to avoid toolbar glitches
 230                     let defSize = btn.getSize().width;
 231
 232                     btn.setText(btn.altText);
 233                     let altSize = btn.getSize().width;
 234
 235                     btn.setText(btn.defaultText);
 236                     btn.setSize({ width: altSize > defSize ? altSize : defSize });
 237                 },
 238             },
 239         },
 240     ],
 241
 242     sortableColumns: false,
 243     viewConfig: {
 244         stripeRows: false,
 245         getRowClass: (record, index) => record.get('Enabled') ? '' : 'proxmox-disabled-row',
 246     },
 247
 248     columns: [
 249         {
 250             xtype: 'checkcolumn',
 251             header: gettext('Enabled'),
 252             dataIndex: 'Enabled',
 253             listeners: {
 254                 beforecheckchange: () => false, // veto, we don't want to allow inline change - to subtle
 255             },
 256             width: 90,
 257         },
 258         {
 259             header: gettext('Types'),
 260             dataIndex: 'Types',
 261             renderer: function(types, cell, record) {
 262                 return types.join(' ');
 263             },
 264             width: 100,
 265         },
 266         {
 267             header: gettext('URIs'),
 268             dataIndex: 'URIs',
 269             renderer: function(uris, cell, record) {
 270                 return uris.join(' ');
 271             },
 272             width: 350,
 273         },
 274         {
 275             header: gettext('Suites'),
 276             dataIndex: 'Suites',
 277             renderer: function(suites, metaData, record) {
 278                 let err = '';
 279                 if (record.data.warnings && record.data.warnings.length > 0) {
 280                     let txt = [gettext('Warning')];
 281                     record.data.warnings.forEach((warning) => {
 282                         if (warning.property === 'Suites') {
 283                             txt.push(warning.message);
 284                         }
 285                     });
 286                     metaData.tdAttr = `data-qtip="${Ext.htmlEncode(txt.join('<br>'))}"`;
 287                     if (record.data.Enabled) {
 288                         metaData.tdCls = 'proxmox-invalid-row';
 289                         err = '<i class="fa fa-fw critical fa-exclamation-circle"></i> ';
 290                     } else {
 291                         metaData.tdCls = 'proxmox-warning-row';
 292                         err = '<i class="fa fa-fw warning fa-exclamation-circle"></i> ';
 293                     }
 294                 }
 295                 return suites.join(' ') + err;
 296             },
 297             width: 130,
 298         },
 299         {
 300             header: gettext('Components'),
 301             dataIndex: 'Components',
 302             renderer: function(components, metaData, record) {
 303                 if (components === undefined) {
 304                     return '';
 305                 }
 306                 let err = '';
 307                 if (components.length === 1) {
 308                     // FIXME: this should be a flag set to the actual repsotiories, i.e., a tristate
 309                     // like production-ready = <yes|no|other> (Option<bool>)
 310                     if (components[0].match(/\w+(-no-subscription|test)\s*$/i)) {
 311                         metaData.tdCls = 'proxmox-warning-row';
 312                         err = '<i class="fa fa-fw warning fa-exclamation-circle"></i> ';
 313
 314                         let qtip = components[0].match(/no-subscription/)
 315                             ? gettext('The no-subscription repository is NOT production-ready')
 316                             : gettext('The test repository may contain unstable updates')
 317                             ;
 318                             metaData.tdAttr = `data-qtip="${Ext.htmlEncode(qtip)}"`;
 319                     }
 320                 }
 321                 return components.join(' ') + err;
 322             },
 323             width: 170,
 324         },
 325         {
 326             header: gettext('Options'),
 327             dataIndex: 'Options',
 328             renderer: function(options, cell, record) {
 329                 if (!options) {
 330                     return '';
 331                 }
 332
 333                 let filetype = record.data.FileType;
 334                 let text = '';
 335
 336                 options.forEach(function(option) {
 337                     let key = option.Key;
 338                     if (filetype === 'list') {
 339                         let values = option.Values.join(',');
 340                         text += `${key}=${values} `;
 341                     } else if (filetype === 'sources') {
 342                         let values = option.Values.join(' ');
 343                         text += `${key}: ${values}<br>`;
 344                     } else {
 345                         throw "unkown file type";
 346                     }
 347                 });
 348                 return text;
 349             },
 350             flex: 1,
 351         },
 352         {
 353             header: gettext('Origin'),
 354             dataIndex: 'Origin',
 355             width: 120,
 356             renderer: (value, meta, rec) => {
 357                 if (typeof value !== 'string' || value.length === 0) {
 358                     value = gettext('Other');
 359                 }
 360                 let cls = 'fa fa-fw fa-question-circle-o';
 361                 if (value.match(/^\s*Proxmox\s*$/i)) {
 362                     cls = 'pmx-itype-icon pmx-itype-icon-proxmox-x';
 363                 } else if (value.match(/^\s*Debian\s*(:?Backports)?$/i)) {
 364                     cls = 'pmx-itype-icon pmx-itype-icon-debian-swirl';
 365                 }
 366                 return `<i class='${cls}'></i> ${value}`;
 367             },
 368         },
 369         {
 370             header: gettext('Comment'),
 371             dataIndex: 'Comment',
 372             flex: 2,
 373         },
 374     ],
 375
 376     features: [
 377         {
 378             ftype: 'grouping',
 379             groupHeaderTpl: '{[ "File: " + values.name ]} ({rows.length} repositor{[values.rows.length > 1 ? "ies" : "y"]})',
 380             enableGroupingMenu: false,
 381         },
 382     ],
 383
 384     store: {
 385         model: 'apt-repolist',
 386         groupField: 'Path',
 387         sorters: [
 388             {
 389                 property: 'Index',
 390                 direction: 'ASC',
 391             },
 392         ],
 393     },
 394
 395     initComponent: function() {
 396         let me = this;
 397
 398         if (!me.nodename) {
 399             throw "no node name specified";
 400         }
 401
 402         me.callParent();
 403     },
 404 });
 405
 406 Ext.define('Proxmox.node.APTRepositories', {
 407     extend: 'Ext.panel.Panel',
 408     xtype: 'proxmoxNodeAPTRepositories',
 409     mixins: ['Proxmox.Mixin.CBind'],
 410
 411     digest: undefined,
 412
 413     product: 'Proxmox VE', // default
 414
 415     controller: {
 416         xclass: 'Ext.app.ViewController',
 417
 418         selectionChange: function(grid, selection) {
 419             let me = this;
 420             if (!selection || selection.length < 1) {
 421                 return;
 422             }
 423             let rec = selection[0];
 424             let vm = me.getViewModel();
 425             vm.set('selectionenabled', rec.get('Enabled'));
 426             vm.notify();
 427         },
 428
 429         updateState: function() {
 430             let me = this;
 431             let vm = me.getViewModel();
 432
 433             let store = vm.get('errorstore');
 434             store.removeAll();
 435
 436             let status = 'good'; // start with best, the helper below will downgrade if needed
 437             let text = gettext('All OK, you have production-ready repositories configured!');
 438
 439             let addGood = message => store.add({ status: 'good', message });
 440             let addWarn = (message, important) => {
 441                 if (status !== 'critical') {
 442                     status = 'warning';
 443                     text = important ? message : gettext('Warning');
 444                 }
 445                 store.add({ status: 'warning', message });
 446             };
 447             let addCritical = (message, important) => {
 448                 status = 'critical';
 449                 text = important ? message : gettext('Error');
 450                 store.add({ status: 'critical', message });
 451             };
 452
 453             let errors = vm.get('errors');
 454             errors.forEach(error => addCritical(`${error.path} - ${error.error}`));
 455
 456             let activeSubscription = vm.get('subscriptionActive');
 457             let enterprise = vm.get('enterpriseRepo');
 458             let nosubscription = vm.get('noSubscriptionRepo');
 459             let test = vm.get('testRepo');
 460             let wrongSuites = vm.get('suitesWarning');
 461
 462             if (!enterprise && !nosubscription && !test) {
 463                 addCritical(
 464                     Ext.String.format(gettext('No {0} repository is enabled, you do not get any updates!'), vm.get('product')),
 465                 );
 466             } else if (errors.length > 0) {
 467                 // nothing extra, just avoid that we show "get updates"
 468             } else if (enterprise && !nosubscription && !test && activeSubscription) {
 469                 addGood(Ext.String.format(gettext('You get supported updates for {0}'), vm.get('product')));
 470             } else if (nosubscription || test) {
 471                 addGood(Ext.String.format(gettext('You get updates for {0}'), vm.get('product')));
 472             }
 473
 474             if (wrongSuites) {
 475                 addWarn(gettext('Some suites are misconfigured'));
 476             }
 477
 478             if (!activeSubscription && enterprise) {
 479                 addWarn(gettext('The enterprise repository is enabled, but there is no active subscription!'));
 480             }
 481
 482             if (nosubscription) {
 483                 addWarn(gettext('The no-subscription repository is not recommended for production use!'));
 484             }
 485
 486             if (test) {
 487                 addWarn(gettext('The test repository may pull in unstable updates and is not recommended for production use!'));
 488             }
 489
 490             if (errors.length > 0) {
 491                 text = gettext('Fatal parsing error for at least one repository');
 492             }
 493
 494             let iconCls = Proxmox.Utils.get_health_icon(status, true);
 495
 496             vm.set('state', {
 497                 iconCls,
 498                 text,
 499             });
 500         },
 501     },
 502
 503     viewModel: {
 504         data: {
 505             product: 'Proxmox VE', // default
 506             errors: [],
 507             suitesWarning: false,
 508             subscriptionActive: '',
 509             noSubscriptionRepo: '',
 510             enterpriseRepo: '',
 511             testRepo: '',
 512             selectionenabled: false,
 513             state: {},
 514         },
 515         formulas: {
 516             enableButtonText: (get) => get('selectionenabled')
 517                 ? gettext('Disable') : gettext('Enable'),
 518         },
 519         stores: {
 520             errorstore: {
 521                 fields: ['status', 'message'],
 522             },
 523         },
 524     },
 525
 526     scrollable: true,
 527     layout: {
 528         type: 'vbox',
 529         align: 'stretch',
 530     },
 531
 532     items: [
 533         {
 534             xtype: 'panel',
 535             border: false,
 536             layout: {
 537                 type: 'hbox',
 538                 align: 'stretch',
 539             },
 540             height: 200,
 541             title: gettext('Status'),
 542             items: [
 543                 {
 544                     xtype: 'box',
 545                     flex: 2,
 546                     margin: 10,
 547                     data: {
 548                         iconCls: Proxmox.Utils.get_health_icon(undefined, true),
 549                         text: '',
 550                     },
 551                     bind: {
 552                         data: '{state}',
 553                     },
 554                     tpl: [
 555                         '<center class="centered-flex-column" style="font-size:15px;line-height: 25px;">',
 556                         '<i class="fa fa-4x {iconCls}"></i>',
 557                         '{text}',
 558                         '</center>',
 559                     ],
 560                 },
 561                 {
 562                     xtype: 'proxmoxNodeAPTRepositoriesErrors',
 563                     name: 'repositoriesErrors',
 564                     flex: 7,
 565                     margin: 10,
 566                     bind: {
 567                         store: '{errorstore}',
 568                     },
 569                 },
 570             ],
 571         },
 572         {
 573             xtype: 'proxmoxNodeAPTRepositoriesGrid',
 574             name: 'repositoriesGrid',
 575             flex: 1,
 576             cbind: {
 577                 nodename: '{nodename}',
 578             },
 579             majorUpgradeAllowed: false, // TODO get release information from an API call?
 580             listeners: {
 581                 selectionchange: 'selectionChange',
 582             },
 583         },
 584     ],
 585
 586     check_subscription: function() {
 587         let me = this;
 588         let vm = me.getViewModel();
 589
 590         Proxmox.Utils.API2Request({
 591             url: `/nodes/${me.nodename}/subscription`,
 592             method: 'GET',
 593             failure: (response, opts) => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
 594             success: function(response, opts) {
 595                 const res = response.result;
 596                 const subscription = !(!res || !res.data || res.data.status.toLowerCase() !== 'active');
 597                 vm.set('subscriptionActive', subscription);
 598                 me.getController().updateState();
 599             },
 600         });
 601     },
 602
 603     updateStandardRepos: function(standardRepos) {
 604         let me = this;
 605         let vm = me.getViewModel();
 606
 607         let addButton = me.down('button[name=addRepo]');
 608
 609         addButton.repoInfo = [];
 610         for (const standardRepo of standardRepos) {
 611             const handle = standardRepo.handle;
 612             const status = standardRepo.status;
 613
 614             if (handle === "enterprise") {
 615                 vm.set('enterpriseRepo', status);
 616             } else if (handle === "no-subscription") {
 617                 vm.set('noSubscriptionRepo', status);
 618             } else if (handle === 'test') {
 619                 vm.set('testRepo', status);
 620             }
 621             me.getController().updateState();
 622
 623             addButton.repoInfo.push(standardRepo);
 624             addButton.digest = me.digest;
 625         }
 626
 627         addButton.setDisabled(false);
 628     },
 629
 630     reload: function() {
 631         let me = this;
 632         let vm = me.getViewModel();
 633         let repoGrid = me.down('proxmoxNodeAPTRepositoriesGrid');
 634
 635         me.store.load(function(records, operation, success) {
 636             let gridData = [];
 637             let errors = [];
 638             let digest;
 639             let suitesWarning = false;
 640
 641             if (success && records.length > 0) {
 642                 let data = records[0].data;
 643                 let files = data.files;
 644                 errors = data.errors;
 645                 digest = data.digest;
 646
 647                 let infos = {};
 648                 for (const info of data.infos) {
 649                     let path = info.path;
 650                     let idx = info.index;
 651
 652                     if (!infos[path]) {
 653                         infos[path] = {};
 654                     }
 655                     if (!infos[path][idx]) {
 656                         infos[path][idx] = {
 657                             origin: '',
 658                             warnings: [],
 659                         };
 660                     }
 661
 662                     if (info.kind === 'origin') {
 663                         infos[path][idx].origin = info.message;
 664                     } else if (info.kind === 'warning' ||
 665                         (info.kind === 'ignore-pre-upgrade-warning' && !repoGrid.majorUpgradeAllowed)
 666                     ) {
 667                         infos[path][idx].warnings.push(info);
 668                     } else {
 669                         throw 'unknown info';
 670                     }
 671                 }
 672
 673
 674                 files.forEach(function(file) {
 675                     for (let n = 0; n < file.repositories.length; n++) {
 676                         let repo = file.repositories[n];
 677                         repo.Path = file.path;
 678                         repo.Index = n;
 679                         if (infos[file.path] && infos[file.path][n]) {
 680                             repo.Origin = infos[file.path][n].origin || Proxmox.Utils.UnknownText;
 681                             repo.warnings = infos[file.path][n].warnings || [];
 682
 683                             if (repo.Enabled && repo.warnings.some(w => w.property === 'Suites')) {
 684                                 suitesWarning = true;
 685                             }
 686                         }
 687                         gridData.push(repo);
 688                     }
 689                 });
 690
 691                 repoGrid.store.loadData(gridData);
 692
 693                 me.updateStandardRepos(data['standard-repos']);
 694             }
 695
 696             me.digest = digest;
 697
 698             vm.set('errors', errors);
 699             vm.set('suitesWarning', suitesWarning);
 700             me.getController().updateState();
 701         });
 702
 703         me.check_subscription();
 704     },
 705
 706     listeners: {
 707         activate: function() {
 708             let me = this;
 709             me.reload();
 710         },
 711     },
 712
 713     initComponent: function() {
 714         let me = this;
 715
 716         if (!me.nodename) {
 717             throw "no node name specified";
 718         }
 719
 720         let store = Ext.create('Ext.data.Store', {
 721             proxy: {
 722                 type: 'proxmox',
 723                 url: `/api2/json/nodes/${me.nodename}/apt/repositories`,
 724             },
 725         });
 726
 727         Ext.apply(me, { store: store });
 728
 729         Proxmox.Utils.monStoreErrors(me, me.store, true);
 730
 731         me.callParent();
 732
 733         me.getViewModel().set('product', me.product);
 734     },
 735 });