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: 'pvetextfield',
  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: 'pvetextfield',
  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: 'pvetextfield',
  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: 'pvetextfield',
  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.create) {
 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: 'textfield',
 168                         name: 'hostname',
 169                         vtype: 'DnsName',
 170                         value: '',
 171                         fieldLabel: gettext('Hostname'),
 172                         allowBlank: true,
 173                         emptyText: me.pveSelNode.data.name
 174                     }
 175                 } : undefined
 176             },
 177             searchdomain: {
 178                 header: gettext('DNS domain'),
 179                 defaultValue: '',
 180                 editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
 181                 renderer: function(value) {
 182                     if (me.getObjectValue('nameserver') || me.getObjectValue('searchdomain')) {
 183                         return value;
 184                     }
 185                     return gettext('use host settings');
 186                 }
 187             },
 188             nameserver: {
 189                 header: gettext('DNS server'),
 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         };
 200
 201         var baseurl = 'nodes/' + nodename + '/lxc/' + vmid + '/config';
 202
 203         var reload = function() {
 204             me.rstore.load();
 205         };
 206
 207         var sm = Ext.create('Ext.selection.RowModel', {});
 208
 209         var run_editor = function() {
 210             var rec = sm.getSelection()[0];
 211             if (!rec) {
 212                 return;
 213             }
 214
 215             var rowdef = rows[rec.data.key];
 216             if (!rowdef.editor) {
 217                 return;
 218             }
 219
 220             var win;
 221             if (Ext.isString(rowdef.editor)) {
 222                 win = Ext.create(rowdef.editor, {
 223                     pveSelNode: me.pveSelNode,
 224                     confid: rec.data.key,
 225                     url: '/api2/extjs/' + baseurl
 226                 });
 227             } else {
 228                 var config = Ext.apply({
 229                     pveSelNode: me.pveSelNode,
 230                     confid: rec.data.key,
 231                     url: '/api2/extjs/' + baseurl
 232                 }, rowdef.editor);
 233                 win = Ext.createWidget(rowdef.editor.xtype, config);
 234             }
 235             //win.load();
 236             win.show();
 237             win.on('destroy', reload);
 238         };
 239
 240         var edit_btn = new PVE.button.Button({
 241             text: gettext('Edit'),
 242             disabled: true,
 243             selModel: sm,
 244             enableFn: function(rec) {
 245                 var rowdef = rows[rec.data.key];
 246                 return !!rowdef.editor;
 247             },
 248             handler: run_editor
 249         });
 250
 251         var set_button_status = function() {
 252             var sm = me.getSelectionModel();
 253             var rec = sm.getSelection()[0];
 254
 255             if (!rec) {
 256                 edit_btn.disable();
 257                 return;
 258             }
 259             var rowdef = rows[rec.data.key];
 260             edit_btn.setDisabled(!rowdef.editor);
 261         };
 262
 263         Ext.apply(me, {
 264             url: "/api2/json/nodes/" + nodename + "/lxc/" + vmid + "/config",
 265             selModel: sm,
 266             cwidth1: 150,
 267             tbar: [ edit_btn ],
 268             rows: rows,
 269             listeners: {
 270                 itemdblclick: run_editor,
 271                 selectionchange: set_button_status,
 272                 activate: reload
 273             }
 274         });
 275
 276         me.callParent();
 277     }
 278 });