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             var 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         var i;
 103
 104         var nodename = me.pveSelNode.data.node;
 105         if (!nodename) {
 106             throw "no node name specified";
 107         }
 108
 109         var vmid = me.pveSelNode.data.vmid;
 110         if (!vmid) {
 111             throw "no VM ID specified";
 112         }
 113
 114         var caps = Ext.state.Manager.get('GuiCap');
 115
 116         var rows = {
 117             hostname: {
 118                 required: true,
 119                 defaultValue: me.pveSelNode.data.name,
 120                 header: gettext('Hostname'),
 121                 editor: caps.vms['VM.Config.Network'] ? {
 122                     xtype: 'proxmoxWindowEdit',
 123                     subject: gettext('Hostname'),
 124                     items: {
 125                         xtype: 'inputpanel',
 126                         items: {
 127                             fieldLabel: gettext('Hostname'),
 128                             xtype: 'textfield',
 129                             name: 'hostname',
 130                             vtype: 'DnsName',
 131                             allowBlank: true,
 132                             emptyText: 'CT' + vmid.toString(),
 133                         },
 134                         onGetValues: function(values) {
 135                             var params = values;
 136                             if (values.hostname === undefined ||
 137                                 values.hostname === null ||
 138                                 values.hostname === '') {
 139                                 params = { hostname: 'CT'+vmid.toString() };
 140                             }
 141                             return params;
 142                         },
 143                     },
 144                 } : undefined,
 145             },
 146             searchdomain: {
 147                 header: gettext('DNS domain'),
 148                 defaultValue: '',
 149                 editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
 150                 renderer: function(value) {
 151                     return value || gettext('use host settings');
 152                 },
 153             },
 154             nameserver: {
 155                 header: gettext('DNS server'),
 156                 defaultValue: '',
 157                 editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
 158                 renderer: function(value) {
 159                     return value || gettext('use host settings');
 160                 },
 161             },
 162         };
 163
 164         var baseurl = 'nodes/' + nodename + '/lxc/' + vmid + '/config';
 165
 166         var reload = function() {
 167             me.rstore.load();
 168         };
 169
 170         var sm = Ext.create('Ext.selection.RowModel', {});
 171
 172         var run_editor = function() {
 173             var rec = sm.getSelection()[0];
 174             if (!rec) {
 175                 return;
 176             }
 177
 178             var rowdef = rows[rec.data.key];
 179             if (!rowdef.editor) {
 180                 return;
 181             }
 182
 183             var win;
 184             if (Ext.isString(rowdef.editor)) {
 185                 win = Ext.create(rowdef.editor, {
 186                     pveSelNode: me.pveSelNode,
 187                     confid: rec.data.key,
 188                     url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config',
 189                 });
 190             } else {
 191                 var config = Ext.apply({
 192                     pveSelNode: me.pveSelNode,
 193                     confid: rec.data.key,
 194                     url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config',
 195                 }, rowdef.editor);
 196                 win = Ext.createWidget(rowdef.editor.xtype, config);
 197                 win.load();
 198             }
 199             //win.load();
 200             win.show();
 201             win.on('destroy', reload);
 202         };
 203
 204         var edit_btn = new Proxmox.button.Button({
 205             text: gettext('Edit'),
 206             disabled: true,
 207             selModel: sm,
 208             enableFn: function(rec) {
 209                 var rowdef = rows[rec.data.key];
 210                 return !!rowdef.editor;
 211             },
 212             handler: run_editor,
 213         });
 214
 215         var revert_btn = new PVE.button.PendingRevert();
 216
 217         var set_button_status = function() {
 218             var sm = me.getSelectionModel();
 219             var rec = sm.getSelection()[0];
 220
 221             if (!rec) {
 222                 edit_btn.disable();
 223                 return;
 224             }
 225             let key = rec.data.key;
 226
 227             let rowdef = rows[key];
 228             edit_btn.setDisabled(!rowdef.editor);
 229
 230             let pending = rec.data['delete'] || me.hasPendingChanges(key);
 231             revert_btn.setDisabled(!pending);
 232         };
 233
 234         Ext.apply(me, {
 235             url: "/api2/json/nodes/" + nodename + "/lxc/" + vmid + "/pending",
 236             selModel: sm,
 237             cwidth1: 150,
 238             interval: 5000,
 239             run_editor: run_editor,
 240             tbar: [edit_btn, revert_btn],
 241             rows: rows,
 242             editorConfig: {
 243                 url: "/api2/extjs/" + baseurl,
 244             },
 245             listeners: {
 246                 itemdblclick: run_editor,
 247                 selectionchange: set_button_status,
 248                 activate: reload,
 249             },
 250         });
 251
 252         me.callParent();
 253
 254         me.on('activate', me.rstore.startUpdate);
 255         me.on('destroy', me.rstore.stopUpdate);
 256         me.on('deactivate', me.rstore.stopUpdate);
 257
 258         me.mon(me.getStore(), 'datachanged', function() {
 259             set_button_status();
 260         });
 261     },
 262 });