www/manager6/lxc/DNS.js

   1 Ext.define('PVE.lxc.DNSInputPanel', {
   2     extend: 'Proxmox.panel.InputPanel',
   3     alias: 'widget.pveLxcDNSInputPanel',
   4
   5     insideWizard: false,
   6
   7     onGetValues: function(values) {
   8         var me = this;
   9
  10         var deletes = [];
  11         if (!values.searchdomain && !me.insideWizard) {
  12             deletes.push('searchdomain');
  13         }
  14
  15         if (values.nameserver) {
  16             let list = values.nameserver.split(/[ ,;]+/);
  17             values.nameserver = list.join(' ');
  18         } else if (!me.insideWizard) {
  19             deletes.push('nameserver');
  20         }
  21
  22         if (deletes.length) {
  23             values.delete = deletes.join(',');
  24         }
  25
  26         return values;
  27     },
  28
  29     initComponent: function() {
  30         var me = this;
  31
  32         var items = [
  33             {
  34                 xtype: 'proxmoxtextfield',
  35                 name: 'searchdomain',
  36                 skipEmptyText: true,
  37                 fieldLabel: gettext('DNS domain'),
  38                 emptyText: gettext('use host settings'),
  39                 allowBlank: true,
  40             },
  41             {
  42                 xtype: 'proxmoxtextfield',
  43                 fieldLabel: gettext('DNS servers'),
  44                 vtype: 'IP64AddressWithSuffixList',
  45                 allowBlank: true,
  46                 emptyText: gettext('use host settings'),
  47                 name: 'nameserver',
  48                 itemId: 'nameserver',
  49             },
  50         ];
  51
  52         if (me.insideWizard) {
  53             me.column1 = items;
  54         } else {
  55             me.items = items;
  56         }
  57
  58         me.callParent();
  59     },
  60 });
  61
  62 Ext.define('PVE.lxc.DNSEdit', {
  63     extend: 'Proxmox.window.Edit',
  64
  65     initComponent: function() {
  66         var me = this;
  67
  68         var ipanel = Ext.create('PVE.lxc.DNSInputPanel');
  69
  70         Ext.apply(me, {
  71             subject: gettext('Resources'),
  72             items: [ipanel],
  73         });
  74
  75         me.callParent();
  76
  77         if (!me.isCreate) {
  78             me.load({
  79                 success: function(response, options) {
  80                     var values = response.result.data;
  81
  82                     if (values.nameserver) {
  83                         values.nameserver.replace(/[,;]/, ' ');
  84                         values.nameserver.replace(/^\s+/, '');
  85                     }
  86
  87                     ipanel.setValues(values);
  88                 },
  89             });
  90         }
  91     },
  92 });
  93
  94 Ext.define('PVE.lxc.DNS', {
  95     extend: 'Proxmox.grid.PendingObjectGrid',
  96     alias: ['widget.pveLxcDNS'],
  97
  98     onlineHelp: 'pct_container_network',
  99
 100     initComponent: function() {
 101         var me = this;
 102
 103         var nodename = me.pveSelNode.data.node;
 104         if (!nodename) {
 105             throw "no node name specified";
 106         }
 107
 108         var vmid = me.pveSelNode.data.vmid;
 109         if (!vmid) {
 110             throw "no VM ID specified";
 111         }
 112
 113         var caps = Ext.state.Manager.get('GuiCap');
 114
 115         var rows = {
 116             hostname: {
 117                 required: true,
 118                 defaultValue: me.pveSelNode.data.name,
 119                 header: gettext('Hostname'),
 120                 editor: caps.vms['VM.Config.Network'] ? {
 121                     xtype: 'proxmoxWindowEdit',
 122                     subject: gettext('Hostname'),
 123                     items: {
 124                         xtype: 'inputpanel',
 125                         items: {
 126                             fieldLabel: gettext('Hostname'),
 127                             xtype: 'textfield',
 128                             name: 'hostname',
 129                             vtype: 'DnsName',
 130                             allowBlank: true,
 131                             emptyText: 'CT' + vmid.toString(),
 132                         },
 133                         onGetValues: function(values) {
 134                             var params = values;
 135                             if (values.hostname === undefined ||
 136                                 values.hostname === null ||
 137                                 values.hostname === '') {
 138                                 params = { hostname: 'CT'+vmid.toString() };
 139                             }
 140                             return params;
 141                         },
 142                     },
 143                 } : undefined,
 144             },
 145             searchdomain: {
 146                 header: gettext('DNS domain'),
 147                 defaultValue: '',
 148                 editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
 149                 renderer: function(value) {
 150                     return value || gettext('use host settings');
 151                 },
 152             },
 153             nameserver: {
 154                 header: gettext('DNS server'),
 155                 defaultValue: '',
 156                 editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
 157                 renderer: function(value) {
 158                     return value || gettext('use host settings');
 159                 },
 160             },
 161         };
 162
 163         var baseurl = 'nodes/' + nodename + '/lxc/' + vmid + '/config';
 164
 165         var reload = function() {
 166             me.rstore.load();
 167         };
 168
 169         var sm = Ext.create('Ext.selection.RowModel', {});
 170
 171         var run_editor = function() {
 172             var rec = sm.getSelection()[0];
 173             if (!rec) {
 174                 return;
 175             }
 176
 177             var rowdef = rows[rec.data.key];
 178             if (!rowdef.editor) {
 179                 return;
 180             }
 181
 182             var win;
 183             if (Ext.isString(rowdef.editor)) {
 184                 win = Ext.create(rowdef.editor, {
 185                     pveSelNode: me.pveSelNode,
 186                     confid: rec.data.key,
 187                     url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config',
 188                 });
 189             } else {
 190                 var config = Ext.apply({
 191                     pveSelNode: me.pveSelNode,
 192                     confid: rec.data.key,
 193                     url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config',
 194                 }, rowdef.editor);
 195                 win = Ext.createWidget(rowdef.editor.xtype, config);
 196                 win.load();
 197             }
 198             //win.load();
 199             win.show();
 200             win.on('destroy', reload);
 201         };
 202
 203         var edit_btn = new Proxmox.button.Button({
 204             text: gettext('Edit'),
 205             disabled: true,
 206             selModel: sm,
 207             enableFn: function(rec) {
 208                 var rowdef = rows[rec.data.key];
 209                 return !!rowdef.editor;
 210             },
 211             handler: run_editor,
 212         });
 213
 214         var revert_btn = new PVE.button.PendingRevert();
 215
 216         var set_button_status = function() {
 217             let button_sm = me.getSelectionModel();
 218             let rec = button_sm.getSelection()[0];
 219
 220             if (!rec) {
 221                 edit_btn.disable();
 222                 return;
 223             }
 224             let key = rec.data.key;
 225
 226             let rowdef = rows[key];
 227             edit_btn.setDisabled(!rowdef.editor);
 228
 229             let pending = rec.data.delete || me.hasPendingChanges(key);
 230             revert_btn.setDisabled(!pending);
 231         };
 232
 233         Ext.apply(me, {
 234             url: "/api2/json/nodes/" + nodename + "/lxc/" + vmid + "/pending",
 235             selModel: sm,
 236             cwidth1: 150,
 237             interval: 5000,
 238             run_editor: run_editor,
 239             tbar: [edit_btn, revert_btn],
 240             rows: rows,
 241             editorConfig: {
 242                 url: "/api2/extjs/" + baseurl,
 243             },
 244             listeners: {
 245                 itemdblclick: run_editor,
 246                 selectionchange: set_button_status,
 247                 activate: reload,
 248             },
 249         });
 250
 251         me.callParent();
 252
 253         me.on('activate', me.rstore.startUpdate);
 254         me.on('destroy', me.rstore.stopUpdate);
 255         me.on('deactivate', me.rstore.stopUpdate);
 256
 257         me.mon(me.getStore(), 'datachanged', function() {
 258             set_button_status();
 259         });
 260     },
 261 });