www/manager6/lxc/DNS.js

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