Attachment #4784 for bug #28389

View | Details | Raw Unified | Return to bug 28389
Collapse All | Expand All




/*
 * Copyright 2012 Univention GmbH
 *
 * http://www.univention.de/
 *
 * All rights reserved.
 *
 * The source code of this program is made available
 * under the terms of the GNU Affero General Public License version 3
 * (GNU AGPL V3) as published by the Free Software Foundation.
 *
 * Binary versions of this program provided by Univention to you as
 * well as other copyrighted, protected or trademarked materials like
 * Logos, graphics, fonts, specific documentations and configurations,
 * cryptographic keys etc. are subject to a license agreement between
 * you and Univention and not subject to the GNU AGPL V3.
 *
 * In the case you use this program under the terms of the GNU AGPL V3,
 * the program is provided in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License with the Debian GNU/Linux or Univention distribution in file
 * /usr/share/common-licenses/AGPL-3; if not, see
 * <http://www.gnu.org/licenses/>.
 */
/*global define*/

define([
	"dojo/_base/array",
	"umc/tools",
	"umc/i18n!umc/modules/setup"
], function(array, tools, _) {
	var self = {
		convertNetmask: function(nm) {
			if (/^[0-9]+$/.test(nm)) {
				return parseInt(nm, 10);
			}
			// TODO: IE8 does not have .reduce
			return array.map(nm.split('.'), function(i) { return parseInt((parseInt(i, 10) + 1) / 32, 10); }).reduce(function(x,y) { return x + y; });
		},
		interfaceTypes: {
			'eth': _('Ethernet'),
			'vlan': _('Virtual LAN'),
			'bond': _('Bonding'),
			'br': _('Bridge')
		},
		getTypeByDevice: function(device) { // TODO: rename
			var key = /^([^\d]+)\d$/.exec(device);
			return key ? key[1] : device;
		},
		getNumberByDevice: function(device) {
			var num = /^[^\d]+(\d+)$/.exec(device);
			return num ? num[1] : device;
		},
		interfaceValues: function() {
			var arr = [];
			tools.forIn(self.interfaceTypes, function(id, label) {
				arr.push({
					id: id,
					label: label
				});
			});
			return arr;
		},
		interfaceValuesDict: function() {
			var d = {};
			tools.forIn(self.interfaceTypes, function(id, label) {
				d[id] = {
					id: id,
					label: label
				};
			});
			return d;
		},
		filterInterfaces: function(/*String[]*/ interfaces, /*Object[]*/ available_interfaces) {
			// filter interfaces, which are available for use (because no interface already uses one of the interface)
			return array.filter(array.map(interfaces, function(/*String*/iface) {
				if (available_interfaces.length && !array.every(available_interfaces, function(/*Object*/item) {

					if (item.interfaceType === 'br' || item.interfaceType === 'bond') {
						// the interface is a bridge or bonding so it can contain subinterfaces
						var key = item.interfaceType === 'br' ? 'bridge_ports' : 'bond_slaves';
						if(item[key] && item[key].length) {
							return array.every(item[key], function(/*String*/_iface) {
								return _iface !== item['interface'];
							});
						}
						return true; // no subtypes (bridge)
					}

					return true; // interface without subinterfaces
				})) {
					return null;
				}
				return {
					id: iface,
					label: iface
				};
			}), function(v) { return v !== null; });
		}
	};

	return self;
});




/*
 * Copyright 2012 Univention GmbH
 *
 * http://www.univention.de/
 *
 * All rights reserved.
 *
 * The source code of this program is made available
 * under the terms of the GNU Affero General Public License version 3
 * (GNU AGPL V3) as published by the Free Software Foundation.
 *
 * Binary versions of this program provided by Univention to you as
 * well as other copyrighted, protected or trademarked materials like
 * Logos, graphics, fonts, specific documentations and configurations,
 * cryptographic keys etc. are subject to a license agreement between
 * you and Univention and not subject to the GNU AGPL V3.
 *
 * In the case you use this program under the terms of the GNU AGPL V3,
 * the program is provided in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License with the Debian GNU/Linux or Univention distribution in file
 * /usr/share/common-licenses/AGPL-3; if not, see
 * <http://www.gnu.org/licenses/>.
 */
/*global define*/

define([
	"dojo/_base/declare",
	"dojo/_base/lang",
	"dojo/_base/array",
	"dojo/aspect",
	"dijit/Dialog",
	"umc/dialog",
	"umc/tools",
	"umc/widgets/Grid",
	"umc/widgets/Form",
	"umc/widgets/ComboBox",
	"umc/widgets/TextBox",
	"umc/modules/setup/InterfaceWizard",
	"umc/modules/setup/types",
	"umc/i18n!umc/modules/setup"
], function(declare, lang, array, aspect, Dialog, dialog, tools, Grid, Form, ComboBox, TextBox, InterfaceWizard, types, _) {
	return declare("umc.modules.setup.InterfaceGrid", [ Grid ], {
		moduleStore: null,

		style: 'width: 100%; height: 200px;',
		query: {},
		sortIndex: null,

		physical_interfaces: [],

		gateway: "",
		nameserver: [],

		constructor: function() {
			lang.mixin(this, {
				columns: [{
					name: 'interface',
					label: _('Interface'),
					width: '15%'
				}, {
					name: 'interfaceType',
					label: _('Type'),
					width: '15%',
					formatter: function(value) {
						return types.interfaceTypes[value] || value;
					}
				}, {
					name: 'information',
					label: _('Information'),
					formatter: function(iface) {
						// This value 'iface' is a hack. We do not know about which identifier this row has so we added the whole information into iface.information
						var back = '';
						if (((iface.interfaceType === 'eth' || iface.interfaceType === 'vlan') && iface.type !== 'manual') || (iface.interfaceType === 'bond' || iface.interfaceType === 'br')) {
							var formatIp = function(ips) {
								return array.map(ips, function(i) { return i[0] + '/' + types.convertNetmask(i[1]);}).join(', ');
							};
							back = _('IP addresses') + ': ';
							if (iface.ip4dynamic) {
								back += 'DHCP';
							} else if (iface.ip4.length){
								back += formatIp(iface.ip4);
							}
							if (iface.ip6dynamic) {
								back += ', <br>SLAAC';
							} else if (iface.ip6.length) {
								back += ', <br>' + formatIp(iface.ip6);
							}
						}
						if (iface.interfaceType === 'br' || iface.interfaceType === 'bond') {
							back += '<br>' + _('Interfaces') + ': ' + iface[iface.interfaceType === 'br' ? 'bridge_ports' : 'bond-slaves'].join(', ');
						}
						return back;
					},
					width: '70%'
				}],
				actions: [{
				// TODO: decide if we show a DHCP query action for every row?!
//					name: 'dhcp_query',
//					label: 'DHCP query',
//					callback: lang.hitch(this, function() {
//						// TODO: interface name
//				//		this._dhcpQuery();
//					}),
//					isMultiAction: false,
//					isStandardAction: true,
//					isContextAction: true
//				}, {
					name: 'edit',
					label: _('Edit'),
					iconClass: 'umcIconEdit',
					isMultiAction: false,
					isStandardAction: true,
					isContextAction: true,
					callback: lang.hitch(this, '_editInterface')
				}, {
					name: 'add',
					label: _('Add interface'),
					iconClass: 'umcIconAdd',
					isMultiAction: false,
					isStandardAction: false,
					isContextAction: false,
					callback: lang.hitch(this, '_addInterface')
				}, {
					name: 'delete',
					label: _('Delete'),
					iconClass: 'umcIconDelete',
					isMultiAction: true,
					isStandardAction: true,
					callback: lang.hitch(this, function(ids) {
						dialog.confirm(_('Please confirm the removal of the %d selected interfaces!', ids.length), [{
							label: _('Delete'),
							callback: lang.hitch(this, '_removeInterface', ids)
						}, {
							label: _('Cancel'),
							'default': true
						}]);
					})
				}]
			});
		},

		_getValueAttr: function() { return this.getAllItems(); },

		_setValueAttr: function(values) {
			// TODO: this method should delete the whole grid items and add the items from values
		},

		setInitialValue: function(values) {
			tools.forIn(values, function(id, value) {
				try {
					this.moduleStore.add(lang.mixin({'interface': id}, value));
				} catch(e) {}
			}, this);
		},

		onChanged: function() {
			// event stub
		},

		updateValues: function(values, create) {
				// if a DHCP query was done the values for gateway and nameserver are set
				// so we trigger on change event
				if (values.gateway !== '') {
					this.set('gateway', values.gateway);
				}
				if (values.nameserver.length) {
					// TODO: decide if the DHCP query can delete all nameservers by sending an empty nameserver?
					this.set('nameserver', values.nameserver);
				}

				if (values.interfaceType === 'eth') {

				} else if (values.interfaceType === 'vlan') {
					// The interface is build from interface.vlan_id
					values['interface'] = values['interface'] + '.' + String(values.vlan_id);

				} else if (values.interfaceType === 'bond' || values.interfaceType === 'br') {
					values.start = true;
					// disable the interfaces which are used by this interface
					var key = values.interfaceType === 'bond' ? 'bond-slaves' : 'bridge_ports';
					this.setDisabledItem(values[key], true);
					// set original values
					array.forEach(values[key], lang.hitch(this, function(ikey) {
						var item = this.moduleStore.get(ikey);
//						item.original = lang.clone(item); // FIXME: RangeError: Maximum call stack size exceeded
						item.original = item;

						// set values to deactivate the interface values
						item.ip4 = [];
						item.ip6 = [];
						item.ip4dynamic = false;
						item.ip6dynamic = false;
						item.type = 'manual';
						item.start = false;

						// FIXME: put does not overwrite
						this.moduleStore.put(item);
						this.moduleStore.remove(item['interface']);
						this.moduleStore.add(item);
					}));
				}

				values.information = values;

				if (!create) {
					this.moduleStore.put( values ); // FIXME: why does put not work? we have to manually remove and add it...
					this.moduleStore.remove(values['interface']);
					this.moduleStore.add( values );
				} else {
					try {
						this.moduleStore.add( values );
					} catch(error) {
						dialog.alert(_('Interface "%s" already exists', values['interface']));
						return;
					}
				}
				this.onChanged();
		},

		_addInterface: function() {
			this._modifyInterface({});
		},

		_editInterface: function(name, props) {
			return this._modifyInterface(props[0]);
		},

		_modifyInterface: function(props) {
			// Add or modify an interface
			if (props.interfaceType) {
				// only edit the existing interace
				props.create = false;
				this._showWizard(props);
				return;
			}

			var form = null;
			var dynamicInterfaceTypeValues = lang.hitch(this, function() {
				// TODO: lookup if interfaces are already in use
				var d = types.interfaceValuesDict();
				if (this.physical_interfaces.length < 2) {
					// We can not use a bonding interface if we don't have two physical interfaces
					delete d.bond;
				}
				if (array.every(this.physical_interfaces, lang.hitch(this, function(iface) {
					var ifaces = this.get('value');
					return ifaces.length !== 0 ? array.some(ifaces, function(val) { return iface === val['interface']; }) : false;
				}))) {
					// if all physical interfaces are configured we can not configure another
					delete d.eth;
				}
				var arr = [];
				tools.forIn(d, function(k, v) {
					arr.push(v);
				});
				return arr;
			});

			var hack = {foo: dynamicInterfaceTypeValues};
			aspect.after(hack, 'foo', function(ret) { 
				if (array.every(ret, function(item) { return item.id !== 'eth'; })) {
					form._widgets.interfaceType.set('value', 'vlan');
				}
			});

			form = new Form({
				widgets: [{
					name: 'interfaceType',
					label: _('Interface type'),
					type: ComboBox,
					value: 'eth', // FIXME: if eth is not possible use vlan
					onChange: lang.hitch(this, function(interfaceType) {
						if (interfaceType) {
							var name = (interfaceType !== 'vlan' ? interfaceType : 'eth');
							var num = 0;
							while(array.some(array.map(this.get('value'), function(item) { return item['interface']; }), function(iface) { return iface == name + String(num); })) {
								num++;
							}
							form.getWidget('interface').set('interface', name + String(num));
						}
					}),
					dynamicValues: hack.foo
				}, {
					name: 'interface',
					label: _('Interface'),
					type: ComboBox,
					depends: ['interfaceType'],
					dynamicValues: lang.hitch(this, function() {
						var interfaceType = form.getWidget('interfaceType').get('value');
						if (interfaceType === 'eth') {
							var available = this.get('value');
							return array.filter(this.physical_interfaces, function(_iface) { return array.every(available, function(item) { return item['interface'] !== _iface; }); });
						} else if (interfaceType === 'vlan') {
							return this.physical_interfaces;
						} else if(interfaceType === 'br' || interfaceType === 'bond' ) {
							var num = 0;
							while(array.some(array.map(this.get('value'), function(item) { return item['interface']; }), function(_iface) { return _iface == interfaceType + String(num); })) {
								num++;
							}
							return [ interfaceType + String(num) ];
						}
					})
//					type: TextBox,
/*					validator: lang.hitch(this, function(value) {
						if(!form) { return true; }
						var interfaceType = form.getWidget('interfaceType').get('value');
						var name = (interfaceType !== 'vlan' ? interfaceType : 'eth');
						if (interfaceType === 'eth' && !array.some(this.physical_interfaces, function(iface) { return iface === value; })) {
							dialog.alert(_('The interface must be one of the physical interfaces: ') + this.physical_interfaces.join(', '));
							return false;
						} else if(interfaceType === 'bond' && 2 > this.physical_interfaces.length) {
							dialog.alert(_('There must be at least two physical interfaces to use a bonding interface'));
							return false;
						}
						return new RegExp('^' + name + '[0-9]+$').test(value);
					})
*/				}],
//				layout: [{
//					label: _('Select an interface type'),
//					layout: ['interfaceType', 'interface']
//				}],
				layout: ['interfaceType', 'interface']
			});

			dialog.confirmForm({
				form: form,
				title: _('Select an interface type'),
				submit: _('Add interface')
			}).then(lang.hitch(this, function(formvals) {
				props = lang.mixin({create: true}, props, formvals);
				this._showWizard(props);
			}));
		},

		_showWizard: function(props) {
			var _dialog = null, wizard = null;

			var _cleanup = function() {
				_dialog.hide();
				_dialog.destroyRecursive();
			};

			var _finished = lang.hitch(this, function(values) {
				this.updateValues(values, props.create);
				_cleanup();
			});
	
			var propvals = {
				values: props,
				'interface': props['interface'],
				interfaceType: props.interfaceType,
				physical_interfaces: this.physical_interfaces,
				available_interfaces: this.get('value'),
				create: props.create,
				onCancel: _cleanup,
				onFinished: _finished
			};
			wizard = new InterfaceWizard(propvals);

			_dialog = new Dialog({
				title: props.create ? _('Add a network interface') : _('Edit a network interface'),
				content: wizard
			});
			_dialog.own(wizard);
			this.own(_dialog);
			_dialog.show();
		},

		_removeInterface: function(ids) {
			array.forEach(ids, function(iid) {
				var item = this.moduleStore.get(iid);
				if (item.interfaceType === 'bond' || item.interfaceType === 'br') {
					// enable the interfaces which were blocked by this interface
					var key = item.interfaceType === 'bond' ? 'bond-slaves' : 'bridge_ports';
					this.setDisabledItem(item[key], false);
					// re set original values
					array.forEach(item[key], lang.hitch(this, function(key) {
						var item = this.moduleStore.get(key);
						if (item.original) {
							this.moduleStore.put(item.original);
						}
					}));
				}

				this.moduleStore.remove(iid);
			}, this);
			this.onChanged();
		}

	});
});




/*
 * Copyright 2012 Univention GmbH
 *
 * http://www.univention.de/
 *
 * All rights reserved.
 *
 * The source code of this program is made available
 * under the terms of the GNU Affero General Public License version 3
 * (GNU AGPL V3) as published by the Free Software Foundation.
 *
 * Binary versions of this program provided by Univention to you as
 * well as other copyrighted, protected or trademarked materials like
 * Logos, graphics, fonts, specific documentations and configurations,
 * cryptographic keys etc. are subject to a license agreement between
 * you and Univention and not subject to the GNU AGPL V3.
 *
 * In the case you use this program under the terms of the GNU AGPL V3,
 * the program is provided in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License with the Debian GNU/Linux or Univention distribution in file
 * /usr/share/common-licenses/AGPL-3; if not, see
 * <http://www.gnu.org/licenses/>.
 */
/*global define*/

define([
	"dojo/_base/declare",
	"dojo/_base/lang",
	"dojo/_base/array",
	"dojo/when",
	"umc/tools",
	"umc/dialog",
	"umc/widgets/Wizard",
	'umc/widgets/Form',
	'umc/widgets/MultiInput',
	'umc/widgets/ComboBox',
	'umc/widgets/TextBox',
	'umc/widgets/MultiSelect',
	'umc/widgets/CheckBox',
	'umc/widgets/NumberSpinner',
	"umc/modules/setup/types",
	"umc/i18n!umc/modules/uvmm"
], function(declare, lang, array, when, tools, dialog, Wizard, Form, MultiInput, ComboBox, TextBox, MultiSelect, CheckBox, NumberSpinner, types, _) {

	return declare("umc.modules.setup.InterfaceWizard", [ Wizard ], {

		'interface': null,

		interfaceType: null, // pre-defined interfaceType will cause a start on configuration page

		values: {},

		umcpCommand: tools.umcpCommand,

		style: 'width: 650px; height: 650px;',
		physical_interfaces: [], // String[] physical interfaces
		available_interfaces: [], // object[] the grid items

//		// do we modify or create an interface
//		_create: false,

		constructor: function(props) {
			props = props || {};
			this.values = props.values || {};

//			this._create = props.create;

			this['interface'] = props['interface'];
			this.interfaceType = props.interfaceType;
			this.physical_interfaces = props.physical_interfaces || [];
			this.available_interfaces = props.available_interfaces || [];

//			var name = (this.interfaceType !== 'vlan' ? this.interfaceType : 'eth');
//			if (!name || !this['interface'] || this['interface'].substr(0, name.length) !== name ) {
//				// name is illegal
//				// TODO: error handling
//				dialog.alert('illegal name');
//			}

			var ethlayout = [{
				label: _('IPv4 network devices'),
				layout: [ 'ip4dynamic', 'dhcpquery', 'ip4' ]
			}, {
				label: _('IPv6 network devices'),
				layout: ['ip6dynamic', 'ip6']
			}];

			if (this.interfaceType === 'vlan') {
				ethlayout.push({
					label: _('Global network settings'),
					layout: [ 'vlan_id' ]
				});
			}

			lang.mixin(this, {
				pages: [{
					// A "normal" ethernet interface
					name: 'eth',
					headerText: _('Interface configuration'),
					helpText: _('Configure the %s network interface %s', types.interfaceTypes[this.interfaceType], this['interface']),
					widgets: [{
						name: 'interfaceType',
						type: TextBox,
						disabled: true,
						visible: false,
						value: props.interfaceType
					}, {
						name: 'interface',
						type: TextBox,
						disabled: true,
						visible: false,
						value: props['interface'],
						size: 'Half',
						label: _('Interface')
					}, {
						name: 'type',
						type: ComboBox,
						visible: false,
						value: '',
						staticValues: [{
							id: '',
							label: ''
						}, {
							id: 'manual',
							label: 'manual'
						}]
					}, {
						name: 'start', // Autostart the interface?
						type: CheckBox,
						value: true,
						visible: false
					}, {
						type: MultiInput,
						name: 'ip4',
						label: '',
						umcpCommand: this.umcpCommand,
						min: 3,
						subtypes: [{
							type: TextBox,
							label: _('IPv4 address'),
							sizeClass: 'Half'
						}, {
							type: TextBox,
							label: _('Netmask'),
							value: '255.255.255.0',
							sizeClass: 'Half'
						}]
					}, {
						name: 'ip4dynamic',
						type: CheckBox,
						onChange: lang.hitch(this, function(value) {
							this._pages.eth._form._widgets.ip4.set('disabled', value);
						}),
						label: _('Dynamic (DHCP)')
					}, {
						type: MultiInput,
						name: 'ip6',
						label: '',
						umcpCommand: this.umcpCommand,
						subtypes: [{
							type: TextBox,
							label: _('IPv6 address'),
							sizeClass: 'One'
						}, {
							type: TextBox,
							label: _('IPv6 prefix'),
							sizeClass: 'OneThird'
						}, {
							type: TextBox,
							label: _('Identifier'),
							sizeClass: 'OneThird'

						}]
					}, {
						type: CheckBox,
						name: 'ip6dynamic',
						onChange: lang.hitch(this, function(value) {
							this._pages.eth._form._widgets.ip6.set('disabled', value);
						}),
						label: _('Autoconfiguration (SLAAC)')
					}, {
						type: CheckBox,
						name: 'eth_vlan',
						value: false,
						label: _('enable Virtual LAN')
					}, {
						type: NumberSpinner,
						name: 'vlan_id',
						size: 'Half',
						value: 2, // some machines does not support 1 // TODO: count up if exists
						constraints: { min: 1, max: 4096 },
						label: _('Virtual interface ID')
					}, {
						// required for DHCP query
						name: 'gateway',
						type: TextBox,
						visible: false
					}, {
						// required for DHCP query
						name: 'nameserver',
						type: MultiInput,
						subtypes: [{ type: TextBox }],
						max: 3,
						visible: false
					}],
					buttons: [{
						name: 'dhcpquery',
						label: 'DHCP-Query',
						callback: lang.hitch(this, function() { this._dhcpQuery(this['interface']); })
					}],
					layout: ethlayout
				}, {
					// A network bridge (software side switch)
					name: 'br',
					headerText: _('Bridge configuration'),
					helpText: _('Configure the %s network interface %s', types.interfaceTypes[this.interfaceType], this['interface']),
					widgets: [{
						// defines which interfaces should be "bridged" together.
						// This can also be 0 to create an interface which does not have an connection to "the outside" (e.g. wanted in virtualisation)
						// There can exists an unlimited amount of interfaces
						name: 'bridge_ports',
						label: _('bridge ports'),
						type: MultiSelect,
						dynamicValues: lang.hitch(this, function() {
							// mixin of physical interfaces and non physical which are not used by other interfaces yet
							return this.filterInterfaces(this.getPhysicalInterfaces(false).concat(this.getAvailableInterfaces(false)));
						})
					}, {
						name: 'bridge_fd',
						label: _('forwarding delay'),
						type: NumberSpinner,
						value: 0
					}],
					layout: [{
						label: _('configure the bridge interface'),
						layout: ['bridge_ports', 'bridge_fd']
					}]
				}, {
					// A bonding interface (fallback if one interface falls out)
					// bond multiple interfaces into one. The used interfaces are not configurable anymore
					name: 'bond',
					headerText: _('Bonding configuration'),
					helpText: _('Configure the %s network interface %s', types.interfaceTypes[this.interfaceType], this['interface']),
					widgets: [{
						name: 'bond-slaves',
						label: _('physical interfaces used for the bonding interface'),
						type: MultiSelect,
						dynamicValues: lang.hitch(this, function() {
							// We can only use physical interfaces for this
							return this.filterInterfaces(this.getPhysicalInterfaces(false));
						})
					}, {
						name: 'primary',
						label: 'primary interface',
						type: ComboBox,
						depends: ['bond-slaves'],
						dynamicValues: lang.hitch(this, function() {
							return this._pages.bond._form._widgets['bond-slaves'].get('value');
						})
					}, {
						name: 'bond-mode',
						label: _('Mode'),
						type: ComboBox,
						staticValues: [{
							id: 0,
							label: 'balance-rr (0)'
						}, {
							id: 1,
							label: 'active-backup (1)'
						}, {
							id: 2,
							label: 'balance-xor (2)'
						}, {
							id: 3,
							label: 'broadcast (3)'
						}, {
							id: 4,
							label: '802.3ad (4)'
						}, {
							id: 5,
							label: 'balance-tlb (5)'
						}, {
							id: 6,
							label: 'balance-alb (6)'
						}]
					}, {
						name: 'miimon',
						label: _('MII link monitoring frequency'),
						type: NumberSpinner,
						constraints: { min: 0 },
						value: 100
					}],
					layout: [{
						label: _('configure the bonding interface'),
						layout: ['bond-slaves', 'primary']
					}, {
						label: _('advanced configuration'),
						layout: ['bond-mode', 'miimon']
					}]
				}]
			});

			return this.inherited(arguments);
		},

		buildRendering: function() {
			this.inherited(arguments);

			// update visibility of widgets
			tools.forIn(this._pages, function(iname, ipage) {
				tools.forIn(ipage._form._widgets, function(iname, iwidget) {
					tools.forIn(types.interfaceTypes, function(typename) {
						// hide every widget which startswith one of the interface types but is not the setted interface type
						if (iname.indexOf(typename + '_') === 0) {
							iwidget.set('visible', typename === this.interfaceType);
						}
					}, this);
				}, this);
			}, this);
		},

		getAvailableInterfaces: function(format) {
			return array.map(this.available_interfaces, function(item) {
				var iface = item['interface'];
				if (format) {
					return {
						id: iface,
						label: iface
					};
				}
				return iface;
			});
		},

		getPhysicalInterfaces: function(format) {
			if (format) {
				return array.map(this.physical_interfaces, function(idev) {
					return {id: idev, label: idev};
				});
			}
			return lang.clone(this.physical_interfaces);
		},

		filterInterfaces: function(/*String[]*/ interfaces) {
			// filter interfaces, which are available for use (because no interface already uses one of the interface)
			return types.filterInterfaces(interfaces, this.available_interfaces);
		},

		setValues: function(values) {
			// set values and trigger onChange event
			tools.forIn(this._pages, function(pagename, page) {
				tools.forIn(values, function(iname, ivalue) {
					if (page._form._widgets[iname]) {
						page._form._widgets[iname].set('value', ivalue);
						page._form._widgets[iname]._set('value', ivalue); // FIXME: how to trigger onChange events // required?
					}
				}, this);
			}, this);
		},

		postCreate: function() {
			this.inherited(arguments);
			this.setValues(this.values);
		},

		startup: function() {
			this.inherited(arguments);
			// FIXME: remove this when the bug is fixed
			this._pages.br._form._widgets.bridge_ports.startup();
			this._pages.bond._form._widgets['bond-slaves'].startup();
		},

		canFinish: function(values) {
			// TODO: conflict if two bonds wants to use the same interface
			var valid = this.interfaceType && this['interface']; // both must be set
			if (!valid) {
				dialog.alert(_('You have to specify a valid interface and interfaceType. Please correct your input.'));
			}

			var interfaceType = this.interfaceType === 'vlan' ? 'eth' : this.interfaceType; // The pagename for vlan interfaces is eth

			if (!(values.ip4.length || values.ip4dynamic || values.ip6.length || values.ip6dynamic)) {
				dialog.alert(_('You have to specify at least one ip address or enable DHCP or SLACC.'));
				return false;
			}
			if (interfaceType === 'bond' && values['bond-slaves'].length < 2) {
				dialog.alert(_('You have to specify at least two interfaces to use for this bond device'));
				return false;
			}

			tools.forIn(this._pages[interfaceType]._form._widgets, function(iname, iwidget) {
				valid = valid && (!iwidget.get('visible') || (!iwidget.isValid || false !== iwidget.isValid()));
				return valid;
			}, this);

			if (!valid) {
				dialog.alert(_('The entered data is not valid. Please correct your input.'));
			}
			return valid;
		},

		next: function(pageName) {
			if (pageName === null) {
				if (this.interfaceType === 'vlan') {
					// The page for vlan interfaces is the same as normal eth interfaces
					return 'eth';
				}
				return this.interfaceType;
			} else if(pageName === 'br' || pageName === 'bond') {
				return 'eth';
			}
		},

		previous: function(pageName) {
			return this.interfaceType;
		},

		hasPrevious: function(currentPage) {
			return currentPage === 'eth' && (this.interfaceType === 'br' || this.interfaceType === 'bond');
		},

		hasNext: function(currentPage) {
			if (currentPage === null) {
				return true;
			}
			return (currentPage === 'br' || currentPage === 'bond');
		},

		_dhcpQuery: function(interfaceName) {
			// TODO: show a notice that this will change gateway and nameserver
			// TODO: show a progressbar and success message?

			// make sure we have an interface selected
			if (!interfaceName) {
				dialog.alert(_('Please choose a network device before querying a DHCP address.'));
				return;
			}
			this.standby(true);
			tools.umcpCommand('setup/net/dhclient', {
				'interface': interfaceName
			}).then(lang.hitch(this, function(data) {
				this.standby(false);

				var result = data.result;
				var netmask = result[interfaceName + '_netmask'];
				var address = result[interfaceName + '_ip'];
				if (!address && !netmask) {
					dialog.alert(_('DHCP query failed.'));
					return;
				}

				this.setValues({
					ip4dynamic: false, // set "Dynamic (DHCP)" to be false if it was not set
					ip4: [[address, netmask]],
					gateway: result.gateway,
					nameserver: [[result.nameserver_1], [result.nameserver_2], [result.nameserver_3]]
				});
			}), lang.hitch(this, function(error) {
				this.standby(false);
				dialog.alert(_('DHCP query failed.'));
			}));
		}
	});
});

(-)umc/js/setup/NetworkPage.js (-262 / +206 lines)

Lines 32-53	Link Here

	"dojo/_base/declare",

	"dojo/_base/declare",

	"dojo/_base/lang",

	"dojo/_base/lang",

	"dojo/_base/array",

	"dojo/_base/array",

	"dojo/on",

	"dojo/aspect",

	"dojo/store/Memory",

	"dojo/store/Observable",

	"dijit/Dialog",

	"umc/tools",

	"umc/tools",

	"umc/dialog",

	"umc/dialog",

	"umc/store",

	"umc/widgets/Page",

	"umc/widgets/Page",

	"umc/widgets/StandbyMixin",

	"umc/widgets/StandbyMixin",

	"umc/widgets/TextBox",

	"umc/widgets/TextBox",

	"umc/widgets/ComboBox",

	"umc/widgets/ComboBox",

	"umc/widgets/MultiInput",

	"umc/widgets/MultiInput",

	"umc/widgets/MultiSelect",

	"umc/widgets/Form",

	"umc/widgets/Form",

	"umc/widgets/Button",

	"umc/modules/setup/InterfaceWizard",

	"umc/modules/setup/InterfaceGrid",

	"umc/modules/setup/types",

	"umc/i18n!umc/modules/setup"

	"umc/i18n!umc/modules/setup"

], function(declare, lang, array, tools, dialog, Page, StandbyMixin, TextBox, ComboBox, MultiInput, MultiSelect, Form, Button, _) {

], function(declare, lang, array, on, aspect, Memory, Observable, Dialog, tools, dialog, store, Page, StandbyMixin, TextBox, ComboBox, MultiInput, Form, InterfaceWizard, InterfaceGrid, types, _) {

	return declare("umc.modules.setup.NetworkPage", [ Page, StandbyMixin ], {

	return declare("umc.modules.setup.NetworkPage", [ Page, StandbyMixin ], {

		// summary:

		// summary:

		//		This class renderes a detail page containing subtabs and form elements

		//		This class renderes a detail page containing subtabs and form elements

		//		in order to edit UDM objects.

		//		in order to edit network interfaces.

		// system-setup-boot

		// system-setup-boot

		wizard_mode: false,

		wizard_mode: false,

Lines 56-61	Link Here

		local_mode: false,

		local_mode: false,

		umcpCommand: tools.umcpCommand,

		umcpCommand: tools.umcpCommand,

		moduleStore: null,

		// internal reference to the formular containing all form widgets of an UDM object

		// internal reference to the formular containing all form widgets of an UDM object

		_form: null,

		_form: null,

Lines 63-160	Link Here

		// dicts of the original IPv4/v6 values

		// dicts of the original IPv4/v6 values

		_orgValues: null,

		_orgValues: null,

		_noteShowed: false,

		_currentRole: null,

		_currentRole: null,

		postMixInProperties: function() {

		physical_interfaces: [],

			this.inherited(arguments);

		postMixInProperties: function() {

			this.title = _('Network');

			this.title = _('Network');

			this.headerText = _('Network settings');

			this.headerText = _('Network settings');

			this.helpText = _('In the <i>network settings</i>, IP addresses (IPv4 and IPv6) as well as name servers, gateways, and HTTP proxies may be specified.');

			this.helpText = _('In the <i>network settings</i>, IP addresses (IPv4 and IPv6) as well as name servers, gateways, and HTTP proxies may be specified.');

			this.moduleStore = new Observable(new Memory({idProperty: 'interface'}));

			this.inherited(arguments);

},

},

		buildRendering: function() {

		buildRendering: function() {

			this.inherited(arguments);

			this.inherited(arguments);

			var widgets = [{

			var widgets = [{

				type: MultiInput,

				type: InterfaceGrid,

				name: 'interfaces_ipv4',

				name: 'interfaces',

				label: '', //_('Interfaces'),

				label: '',

				umcpCommand: this.umcpCommand,

				moduleStore: this.moduleStore

				subtypes: [{

					type: ComboBox,

					label: _('Interface'),

					dynamicValues: lang.hitch(this, function() {

						return this.umcpCommand('setup/net/interfaces').then(lang.hitch(this, function(data) {

							// for ipv4 interfaces, we can have a virtual one, as well

							var list = [];

							array.forEach(data.result, function(idev) {

								var idev2 = {

									id: idev + '_virtual',

									label: idev + ' (' + _('virtual') + ')'

};

								list.push(idev, idev2);

							}, this);

100

							return list;

101

						}));

102

}),

103

					sizeClass: 'OneThird'

104

				}, {

105

					type: TextBox,

106

					label: _('IPv4 address'),

107

					sizeClass: 'Half'

108

				}, {

109

					type: TextBox,

110

					label: _('Netmask'),

111

					sizeClass: 'Half'

112

				}, {

113

					type: ComboBox,

114

					label: _('Dynamic (DHCP)'),

115

					staticValues: [

116

						{ id: 'false', label: _('Deactivated') },

117

						{ id: 'true', label: _('Activated') }

118

],

119

					sizeClass: 'OneThird'

120

				}, {

121

					type: Button,

122

					label: 'DHCP query',

123

					callback: lang.hitch(this, '_dhcpQuery')

124

}]

125

			}, {

			}, {

126

				type: MultiInput,

				type: ComboBox,

127

				name: 'interfaces_ipv6',

				name: 'interfaces/primary',

128

				label: '', //_('Interfaces'),

				label: _('primary network interface'),

129

				umcpCommand: this.umcpCommand,

100

				depends: ['interfaces', 'gateway'],

130

				subtypes: [{

101

				dynamicValues: lang.hitch(this, function() {

131

					type: ComboBox,

102

					// FIXME: howto trigger dynamicValues update

132

					label: _('Interface'),

103

					// The primary interface can be of any type

133

					dynamicValues: 'setup/net/interfaces',

104

					return array.map(this._form._widgets.interfaces.get('value'), function(item) {

134

					sizeClass: 'OneThird'

105

						return {id: item['interface'], label: item['interface']};

135

				}, {

106

});

136

					type: TextBox,

107

})

137

					label: _('IPv6 address'),

138

					sizeClass: 'One'

139

				}, {

140

					type: TextBox,

141

					label: _('IPv6 prefix'),

142

					sizeClass: 'OneThird'

143

				}, {

144

					type: TextBox,

145

					label: _('Identifier'),

146

					sizeClass: 'OneThird'

147

148

}]

149

			}, {

108

			}, {

150

				type: MultiSelect,

151

				name: 'dynamic_interfaces_ipv6',

152

				label: _('Autoconfiguration (SLAAC)'),

153

				umcpCommand: this.umcpCommand,

154

				dynamicValues: 'setup/net/interfaces',

155

				autoHeight: true,

156

				sizeClass: 'OneThird'

157

			}, {

158

				type: TextBox,

109

				type: TextBox,

159

				name: 'gateway',

110

				name: 'gateway',

160

				label: _('Gateway (IPv4)')

111

				label: _('Gateway (IPv4)')

Lines 181-194	Link Here

181

}];

132

}];

182

133

183

			var layout = [{

134

			var layout = [{

184

				label: _('IPv4 network devices'),

135

				label: _('IP network devices'),

185

				layout: ['interfaces_ipv4']

136

				layout: ['interfaces']

186

			}, {

137

			}, {

187

				label: _('IPv6 network devices'),

188

				layout: ['interfaces_ipv6', 'dynamic_interfaces_ipv6']

189

			}, {

190

				label: _('Global network settings'),

138

				label: _('Global network settings'),

191

				layout: [ ['gateway', 'ipv6/gateway'], 'nameserver', 'dns/forwarder', 'proxy/http']

139

				layout: [ ['gateway', 'ipv6/gateway'], 'interfaces/primary', 'nameserver', 'dns/forwarder', 'proxy/http']

192

}];

140

}];

193

141

194

			this._form = new Form({

142

			this._form = new Form({

Lines 198-299	Link Here

198

});

146

});

199

			this._form.on('submit', lang.hitch(this, 'onSave'));

147

			this._form.on('submit', lang.hitch(this, 'onSave'));

200

148

201

			// add onChange handlers that show the note

149

			// only show notes in an joined system in productive mode

202

			array.forEach(['interfaces_ipv4', 'interfaces_ipv6'], function(iname) {

150

			if (!this.wizard_mode) {

203

				var iwidget = this._form.getWidget(iname);

151

				// show a note if interfaces changes

204

				this.own(iwidget.watch('value', lang.hitch(this, function() {

152

				this.own(on.once(this._form._widgets.interfaces, 'changed', lang.hitch(this, function() {

205

					if (iwidget.focused) {

153

					// TODO: only show it when IP changes??

206

						this._showNote();

154

					this.addNote(_('Changing IP address configurations may result in restarting or stopping services. This can have severe side-effects when the system is in productive use at the moment.'));

207

208

				})));

155

				})));

209

			}, this);

210

211

			this.addChild(this._form);

212

},

213

214

		_showNote: function() {

215

			if (!this._noteShowed) {

216

				this._noteShowed = true;

217

				this.addNote(_('Changing IP address configurations may result in restarting or stopping services. This can have severe side-effects when the system is in productive use at the moment.'));

218

156

219

},

220

157

221

		_dhcpQuery: function(item, idx) {

158

			// update interfaces/primary when there are changes on the interfaces

222

			// switch on standby animation

159

			this._form._widgets.interfaces.on('changed', lang.hitch(this, function() {

223

			this.standby(true);

160

				this._form._widgets['interfaces/primary'].reloadDynamicValues();

161

			}));

224

162

225

			// make sure we have an interface selected

163

			// FIXME: grid does not have .ready

226

			if (!item || !item[0] || typeof item[0] != "string") {

164

			// reload interfaces/primary when interfaces is ready

227

				dialog.alert(_('Please choose a network device before querying a DHCP address.'));

165

//			this._form._widgets.interfaces.ready().then(lang.hitch(this, function() {

228

				this.standby(false);

166

//				this._form._widgets['interfaces/primary'].reloadDynamicValues();

229

				return;

167

//			}));

230

231

			if (item[0].indexOf('_virtual') >= 0) {

232

				dialog.alert(_('A virtual network device cannot be used for DHCP.'));

233

				this.standby(false);

234

				return;

235

236

			this.umcpCommand('setup/net/dhclient', {

237

				'interface': item[0]

238

			}).then(lang.hitch(this, function(data) {

239

				// switch off standby animation

240

				this.standby(false);

241

168

242

				var result = data.result;

169

			this.addChild(this._form);

243

				var netmask = result[item[0] + '_netmask'];

244

				var address = result[item[0] + '_ip'];

245

				if (!address && !netmask) {

246

					dialog.alert(_('DHCP query failed.'));

247

					return;

248

249

170

250

				// set the queried IP and netmask

171

			// FIXME: as the grid is a border container it has to be resized manually

251

				var devicesWidget = this._form.getWidget('interfaces_ipv4');

172

			this.own(aspect.after(this, 'resize', lang.hitch(this, function() {

252

				var val = devicesWidget.get('value');

173

					this._form._widgets.interfaces.resize();

253

				if (address) {

174

			})));

254

					val[idx][1] = address;

175

},

255

256

				if (netmask) {

257

					val[idx][2] = netmask;

258

259

				// set "Dynamic (DHCP)" to be false if it was not set

260

				if ( val[idx][3] === '') {

261

					val[idx][3] = 'false';

262

263

176

264

				// set gateway

177

		postCreate: function() {

265

				devicesWidget.set('value', val);

178

			this.inherited(arguments);

266

				if (result.gateway) {

179

			// The grid contains changes if a DHCP request was made

267

					var gatewayWidget = this._form.getWidget('gateway');

180

			this._form._widgets.interfaces.watch('gateway', lang.hitch(this, function(name, old, value) {

268

					gatewayWidget.set('value', result.gateway);

181

				// set gateway from dhcp request

269

182

				this._form._widgets.gateway.set('value', value);

270

183

			}));

184

			this._form._widgets.interfaces.watch('nameserver', lang.hitch(this, function(name, old, value) {

271

				// read nameserver or dns/forwarder

185

				// read nameserver or dns/forwarder

272

				var nameserverWidget;

186

				var nameserverWidget;

273

				if (this._form.getWidget('nameserver').get('visible')) {

187

				if (this._form.getWidget('nameserver').get('visible')) {

274

					nameserverWidget = this._form.getWidget('nameserver');

188

					nameserverWidget = this._form.getWidget('nameserver');

275

				} else {

189

				} else {

276

					// if nameserver is not visable, set dns/forwarder

190

					// if nameserver is not visible, set dns/forwarder

277

					nameserverWidget = this._form.getWidget('dns/forwarder');

191

					nameserverWidget = this._form.getWidget('dns/forwarder');

278

192

279

				val = nameserverWidget.get('value');

193

				// set nameserver from dhcp request

280

				if (result.nameserver_1) {

194

				nameserverWidget.set('value', value);

281

					val[0] = result.nameserver_1;

282

283

				if (result.nameserver_2) {

284

					val[1] = result.nameserver_2;

285

286

				if (result.nameserver_3) {

287

					val[2] = result.nameserver_3;

288

289

				nameserverWidget.set('value', val);

290

291

			}), lang.hitch(this, function() {

292

				// switch off standby animation

293

				this.standby(false);

294

			}));

195

			}));

295

},

196

},

296

197

198

		// TODO: reimplement

297

		sortInterfaces: function(x, y) {

199

		sortInterfaces: function(x, y) {

298

			if (x.id != y.id) {

200

			if (x.id != y.id) {

299

				// this is for ipv6 types, the id 'default' should be listed as first device

201

				// this is for ipv6 types, the id 'default' should be listed as first device

Lines 317-326	Link Here

317

219

318

			return 0;

220

			return 0;

319

},

221

},

320

222

321

		setValues: function(_vals) {

223

		setValues: function(_vals) {

322

			// save a copy of all original values that may be lists

224

			// save a copy of all original values that may be lists

323

			var r = /^(interfaces\/[^\/]+\/|nameserver[1-3]|dns\/forwarder[1-3])$/;

225

			var r = /^(interfaces\/.*|nameserver[1-3]|dns\/forwarder[1-3])$/;

324

			this._orgValues = {};

226

			this._orgValues = {};

325

			tools.forIn(_vals, function(ikey, ival) {

227

			tools.forIn(_vals, function(ikey, ival) {

326

				if (r.test(ikey)) {

228

				if (r.test(ikey)) {

Lines 328-336	Link Here

328

230

329

			}, this);

231

			}, this);

330

232

233

			// set all available interfaces

234

			this.physical_interfaces = _vals.interfaces;

235

331

			// copy values that do not change in their name

236

			// copy values that do not change in their name

332

			var vals = {};

237

			var vals = {};

333

			array.forEach(['gateway', 'ipv6/gateway', 'proxy/http'], function(ikey) {

238

			array.forEach(['gateway', 'ipv6/gateway', 'proxy/http', 'interfaces/primary'], function(ikey) {

334

				vals[ikey] = _vals[ikey];

239

				vals[ikey] = _vals[ikey];

335

});

240

});

336

241

Lines 375-391	Link Here

375

				sortedIpv4.push(ival);

280

				sortedIpv4.push(ival);

376

});

281

});

377

282

378

			// translate to our datastructure

379

			vals.interfaces_ipv4 = [];

380

			array.forEach(sortedIpv4, function(idev) {

381

				vals.interfaces_ipv4.push([

382

					idev.virtual ? idev.device + '_virtual' : idev.device,

383

					idev.address || '',

384

					idev.netmask || '',

385

					idev.type == 'dynamic' || idev.type == 'dhcp' ? 'true' : 'false'

386

]);

387

});

388

389

			// copy ipv6 interfaces

283

			// copy ipv6 interfaces

390

			r = /interfaces\/([^\/]+)\/ipv6\/([^\/]+)\/(.+)/;

284

			r = /interfaces\/([^\/]+)\/ipv6\/([^\/]+)\/(.+)/;

391

			var ipv6 = {};

285

			var ipv6 = {};

Lines 408-420	Link Here

408

			tools.forIn(ipv6, function(ikey, ival) {

302

			tools.forIn(ipv6, function(ikey, ival) {

409

				sortedIpv6.push(ival);

303

				sortedIpv6.push(ival);

410

});

304

});

411

			sortedIpv6.sort(this.sortInterfaces);

305

//			sortedIpv6.sort(this.sortInterfaces);

412

306

413

			// translate to our datastructure

307

			// translate to our datastructure

414

			vals.interfaces_ipv6 = [];

308

			var interfaces = {};

309

			vals.ip4dynamic = false;

310

			array.forEach(sortedIpv4, function(idev) {

311

				interfaces[idev.device] = interfaces[idev.device] || { 'interface': idev.device, interfaceType: types.getTypeByDevice(idev.device) };

312

				if (!idev.virtual) {

313

					interfaces[idev.device].ip4dynamic = (idev.type == 'dynamic' || idev.type == 'dhcp');

314

315

				interfaces[idev.device].ip4 = interfaces[idev.device].ip4 || [];

316

				interfaces[idev.device].ip4.push([

317

					idev.address || '',

318

					idev.netmask || ''

319

]);

320

				interfaces[idev.device].ip6 = [];

321

});

322

323

			// translate to our datastructure

415

			array.forEach(sortedIpv6, function(idev) {

324

			array.forEach(sortedIpv6, function(idev) {

416

				vals.interfaces_ipv6.push([

325

				interfaces[idev.device] = interfaces[idev.device] || {};

417

					idev.device,

326

				interfaces[idev.device].ip6 = interfaces[idev.device].ip6 || [];

327

				interfaces[idev.device].ip6.push([

418

					idev.address || '',

328

					idev.address || '',

419

					idev.prefix || '',

329

					idev.prefix || '',

420

					idev.id || ''

330

					idev.id || ''

Lines 423-436	Link Here

423

333

424

			// dynamic ipv6 interfaces

334

			// dynamic ipv6 interfaces

425

			r = /interfaces\/([^\/]+)\/ipv6\/acceptRA/;

335

			r = /interfaces\/([^\/]+)\/ipv6\/acceptRA/;

426

			vals.dynamic_interfaces_ipv6 = [];

427

			array.forEach(sortedKeys, function(ikey) {

336

			array.forEach(sortedKeys, function(ikey) {

428

				var match = ikey.match(r);

337

				var match = ikey.match(r);

429

				if (tools.isTrue(_vals[ikey]) && match) {

338

				if (match) {

430

					vals.dynamic_interfaces_ipv6.push(match[1]);

339

					interfaces[match[1]].ip6dynamic = tools.isTrue(_vals[ikey]);

431

340

432

});

341

});

433

342

343

			tools.forIn(interfaces, function(device) {

344

				// hack it! the formatter does not know about itself

345

				interfaces[device].information = interfaces[device];

346

});

347

348

			vals.interfaces = interfaces;

349

			// set all physical interfaces for the grid here, the info does not exists on grid creation

350

			this._form._widgets.interfaces.set('physical_interfaces', this.physical_interfaces);

351

434

			// only show forwarder for master, backup, and slave

352

			// only show forwarder for master, backup, and slave

435

			this._currentRole = _vals['server/role'];

353

			this._currentRole = _vals['server/role'];

436

			var showForwarder = this._currentRole == 'domaincontroller_master' || this._currentRole == 'domaincontroller_backup' || this._currentRole == 'domaincontroller_slave';

354

			var showForwarder = this._currentRole == 'domaincontroller_master' || this._currentRole == 'domaincontroller_backup' || this._currentRole == 'domaincontroller_slave';

Lines 440-457	Link Here

440

			this._form.getWidget('nameserver').set('visible', ! ( this.wizard_mode && this._currentRole == 'domaincontroller_master' ) );

358

			this._form.getWidget('nameserver').set('visible', ! ( this.wizard_mode && this._currentRole == 'domaincontroller_master' ) );

441

			// set values

359

			// set values

442

			this._form.setFormValues(vals);

360

			this._form.setFormValues(vals);

361

			this._form._widgets.interfaces.setInitialValue(vals.interfaces);

443

362

444

			// only show notes in an joined system in productive mode

445

			this._noteShowed = this.wizard_mode;

446

			this.clearNotes();

363

			this.clearNotes();

447

},

364

},

448

365

449

		getValues: function() {

366

		getValues: function() {

450

			var _vals = this._form.gatherFormValues();

367

			var _vals = this._form.get('value');

451

			var vals = {};

368

			var vals = {};

452

369

453

			// copy values that do not change in their name

370

			// copy values that do not change in their name

454

			array.forEach(['gateway', 'ipv6/gateway', 'proxy/http'], function(ikey) {

371

			array.forEach(['gateway', 'ipv6/gateway', 'proxy/http', 'interfaces/primary'], function(ikey) {

455

				vals[ikey] = _vals[ikey];

372

				vals[ikey] = _vals[ikey];

456

});

373

});

457

374

Lines 462-507	Link Here

462

});

379

});

463

});

380

});

464

381

465

			// copy ipv4 interfaces

382

			array.forEach(_vals.interfaces, function(iface) {

466

			var iipv4Virtual = {};  // counter for the virtual interfaces

383

				var iname = iface['interface'];

467

			array.forEach(_vals.interfaces_ipv4, function(ival) {

384

				if ((iface.interfaceType === 'eth' || iface.interfaceType === 'vlan') && iface.type === 'manual') {

468

				var idev = ival[0];

385

					// The device is used in a bridge or bonding

469

				var iaddress = ival[1];

386

					vals['interfaces/' + iname + '/type'] = iface.type; //assert type == manual

470

				var imask = ival[2];

387

					vals['interfaces/' + iname + '/start'] = iface.start; // assert start == false

471

				var idynamic = ival[3] == 'true';

388

					// TODO: do we have to remove ip, etc. here?

472

				var iname = idev;

389

					vals['interfaces/' + iname + '/address'] = '';

473

				if (iname.indexOf('_virtual') >= 0) {

390

					vals['interfaces/' + iname + '/netmask'] = '';

474

					if (!(idev in iipv4Virtual)) {

391

475

						// first virtual interfaces for this device

392

				} else {

476

						iipv4Virtual[idev] = 0;

393

					if (iface.interfaceType === 'br' || iface.interfaceType === 'bond') {

394

						// for bonding and bridging this must/should be set

395

						// for eth and vlan we don't want to overwrite existing settings

396

						vals['interfaces/' + iname + '/start'] = iface.start;

397

						if (iface.interfaceType === 'br') {

398

							var bp = iface.bridge_ports.length ? iface.bridge_ports.join(' ') : 'none';

399

							vals['interfaces/' + iname + '/options/1'] = 'bridge_ports ' + bp;

400

							vals['interfaces/' + iname + '/options/2'] = 'bridge_fd ' + iface.bridge_fd;

401

						} else if(iface.interfaceType === 'bond') {

402

							vals['interfaces/' + iname + '/options/1'] = 'bond-slaves ' + iface['bond-slaves'].join(' ');

403

							// FIXME TODO bond-primary ??

404

							vals['interfaces/' + iname + '/options/2'] = 'bond-mode ' + iface['bond-mode'];

405

							vals['interfaces/' + iname + '/options/3'] = 'miimon ' + iface.miimon;

406

							vals['interfaces/' + iname + '/options/4'] = 'primary ' + iface.primary;

407

408

477

409

478

					iname = iname.replace('virtual', iipv4Virtual[idev]);

410

					if (iface.ip4.length) {

479

					++iipv4Virtual[idev]; // count up the number of virtual interfaces for this device

411

						// IPv4

480

412

						array.forEach(iface.ip4, function(virtval, i) {

481

				else {

413

							var iaddress = virtval[0];

482

					// only real interfaces may use DHCP

414

							var imask = virtval[1];

483

					if (idynamic) {

415

							if (i === 0) {

416

								// IP address

417

								vals['interfaces/' + iname + '/address'] = iaddress;

418

								vals['interfaces/' + iname + '/netmask'] = imask;

419

							} else {

420

								// virtual ip adresses

421

								vals['interfaces/' + iname + '_' + (i-1) + '/address'] = iaddress;

422

								vals['interfaces/' + iname + '_' + (i-1) + '/netmask'] = imask;

423

424

});

425

					} else if (iface.ip4dynamic) {

426

						// DHCP

484

						vals['interfaces/' + iname + '/type'] = 'dynamic';

427

						vals['interfaces/' + iname + '/type'] = 'dynamic';

485

428

486

487

				vals['interfaces/' + iname + '/address'] = iaddress;

488

				vals['interfaces/' + iname + '/netmask'] = imask;

489

});

490

429

491

			// copy ipv6 interfaces

430

					// IPv6 SLAAC

492

			array.forEach(_vals.interfaces_ipv6, function(ival) {

431

					vals['interfaces/' + iname + '/ipv6/acceptRA'] = iface.ip6dynamic ? 'true' : 'false';

493

				var idev = ival[0];

494

				var iaddress = ival[1];

495

				var iprefix = ival[2];

496

				var iid = ival[3];

497

				vals['interfaces/' + idev + '/ipv6/' + iid + '/address'] = iaddress;

498

				vals['interfaces/' + idev + '/ipv6/' + iid + '/prefix'] = iprefix;

499

});

500

432

501

			// dynamic ipv6 interfaces

433

					if (!iface.ip6dynamic) {

502

			//array.forEach(_vals.dynamic_interfaces_ipv6, function(idev) {

434

						// IPv6

503

			array.forEach(this._form.getWidget('dynamic_interfaces_ipv6').getAllItems(), function(iitem) {

435

						array.forEach(iface.ip6, function(ip6val) {

504

				vals['interfaces/' + iitem.id + '/ipv6/acceptRA'] = (array.indexOf(_vals.dynamic_interfaces_ipv6, iitem.id) >= 0) ? 'true' : 'false';

436

							var iaddress = ip6val[0];

437

							var iprefix = ip6val[1];

438

							var iidentifier = ip6val[2];

439

							vals['interfaces/' + iname + '/ipv6/' + iidentifier + '/address'] = iaddress;

440

							vals['interfaces/' + iname + '/ipv6/' + iidentifier + '/prefix'] = iprefix;

441

});

442

443

505

});

444

});

506

445

507

			// add empty entries for all original entries that are not used anymore

446

			// add empty entries for all original entries that are not used anymore

Lines 517-557	Link Here

517

		getSummary: function() {

456

		getSummary: function() {

518

			// a list of all components with their labels

457

			// a list of all components with their labels

519

			var allInterfaces = {};

458

			var allInterfaces = {};

520

			array.forEach(this._form.getWidget('dynamic_interfaces_ipv6').getAllItems(), function(iitem) {

521

				allInterfaces[iitem.id] = iitem.label;

522

				allInterfaces[iitem.id + '_virtual'] = iitem.label + ' [' + _('virtual') + ']';

523

			}, this);

524

459

460

			allInterfaces = array.map(this._form._widgets.interfaces.get('value'), function(item) {

461

				return item['interface'];

462

});

463

525

			// list of all IPv4 network devices

464

			// list of all IPv4 network devices

526

			var vals = this._form.gatherFormValues();

465

			var vals = this._form.get('value');

527

			var ipv4Str = '<ul>';

466

			var ipv4Str = array.map(array.filter(vals.interfaces, function(idev) {

528

			array.forEach(vals.interfaces_ipv4, function(idev) {

467

				return idev.ip4.length;

529

				if (idev[1]) {

468

			}), function(idev) {

530

					// address is given

469

				if (idev.ip4dynamic) {

531

					ipv4Str += '<li>' +

470

					return idev['interface'] + ': DHCP';

532

							idev[1] + '/' + idev[2] +

533

							' (' +

534

								allInterfaces[idev[0]] +

535

								(idev[3] == 'true' ? ', DHCP' : '') +

536

							')</li>';

537

				} else {

538

					// address is not given: must be DHCP

539

					ipv4Str += '<li>' +

540

							allInterfaces[idev[0]] + ': DHCP' +

541

							'</li>';

542

471

472

				return idev['interface'] + ': ' + array.map(idev.ip4, function(ip4) {

473

					// address/netmask

474

					return ip4[0] + '/' + ip4[1];

475

				}).join(', ');

543

});

476

});

544

			ipv4Str += '</ul>';

545

477

546

			// list of all IPv6 network devices

478

			ipv4Str = ipv4Str.length ? '<ul><li>' + ipv4Str.join('</li><li>') + '</li></ul>' : '';

547

			var ipv6Str = '<ul>';

479

548

			array.forEach(vals.interfaces_ipv6, function(idev) {

480

			var ipv6Str = array.map(array.filter(vals.interfaces, function(idev) {

549

				ipv6Str += '<li>' +

481

				return idev.ip6 && idev.ip6.length;

550

						idev[1] + ' - ' + idev[2] + '/' + idev[3] +

482

			}), function(idev) {

551

						' (' + idev[0] + ')</li>';

483

				if (idev.ip6dynamic) {

484

					return idev['interface'] + ': DHCP';

485

486

				return idev['interface'] + ': ' + array.map(idev.ip6, function(ip6) {

487

					// adress - prefix/identifier

488

					return ip6[0] + ' - ' + ip6[1] + '/' + ip6[2];

489

				}).join(', '); // TODO: <br> or <li>

552

});

490

});

553

			ipv6Str += '</ul>';

554

491

492

			ipv6Str = ipv6Str.length ? '<ul><li>' + ipv6Str.join('</li><li>') + '</li></ul>' : '';

493

555

			// create a verbose list of all settings

494

			// create a verbose list of all settings

556

			return [{

495

			return [{

557

				variables: ['gateway'],

496

				variables: ['gateway'],

Lines 562-572	Link Here

562

				description: _('Gateway (IPv6)'),

501

				description: _('Gateway (IPv6)'),

563

				values: vals['ipv6/gateway']

502

				values: vals['ipv6/gateway']

564

			}, {

503

			}, {

565

				variables: [/nameserver.*/],

504

				variables: [(/nameserver.*/)],

566

				description: _('Domain name server'),

505

				description: _('Domain name server'),

567

				values: vals['nameserver'].join(', ')

506

				values: vals['nameserver'].join(', ')

568

			}, {

507

			}, {

569

				variables: [/dns\/forwarder.*/],

508

				variables: [(/dns\/forwarder.*/)],

570

				description: _('External name server'),

509

				description: _('External name server'),

571

				values: vals['dns/forwarder'].join(', ')

510

				values: vals['dns/forwarder'].join(', ')

572

			}, {

511

			}, {

Lines 574-590	Link Here

574

				description: _('HTTP proxy'),

513

				description: _('HTTP proxy'),

575

				values: vals['proxy/http']

514

				values: vals['proxy/http']

576

			}, {

515

			}, {

577

				variables: [/^interfaces\/[^_\/]+(_[0-9]+)?\/(?!ipv6).*/],

516

				variables: [(/^interfaces\/[^_\/]+(_[0-9]+)?\/(?!ipv6).*/)],

578

				description: _('IPv4 network devices'),

517

				description: _('IPv4 network devices'),

579

				values: ipv4Str

518

				values: ipv4Str

580

			}, {

519

			}, {

581

				variables: [/^interfaces\/[^\/]+\/ipv6\/.*\/(prefix|address)$/],

520

				variables: [(/^interfaces\/[^\/]+\/ipv6\/.*\/(prefix|address)$/)],

582

				description: _('IPv6 network devices'),

521

				description: _('IPv6 network devices'),

583

				values: ipv6Str

522

				values: ipv6Str

584

			}, {

523

			}, {

585

				variables: [/^interfaces\/[^\/]+\/ipv6\/acceptRA/],

524

				variables: ['interfaces/primary'],

586

				description: _('IPv6 interfaces with autoconfiguration (SLAAC)'),

525

				description: _('primary network interface'),

587

				values: vals['dynamic_interfaces_ipv6'].length ? vals['dynamic_interfaces_ipv6'].join(', ') : _('No device')

526

				values: vals['interfaces/primary']

527

//			}, {

528

				// FIXME

529

//				variables: [/^interfaces\/[^\/]+\/ipv6\/acceptRA/],

530

//				description: _('IPv6 interfaces with autoconfiguration (SLAAC)'),

531

//				values: vals['dynamic_interfaces_ipv6'].length ? vals['dynamic_interfaces_ipv6'].join(', ') : _('No device')

588

}];

532

}];

589

},

533

},

590

534




msgstr ""
"Project-Id-Version: univention-management-console-module-setup\n"
"Report-Msgid-Bugs-To: packages@univention.de\n"
"POT-Creation-Date: 2012-11-09 13:20+0100\n"
"PO-Revision-Date: 2012-02-20 11:34+0100\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"

"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: umc/js/setup/SystemRolePage.js:88
msgid ""
"<h2>Backup domain controller</h2>All the domain data and SSL security "
"certificates are saved as read-only copies on servers with the backup domain "

"als Fallback-System des DC Master. Sollte dieser ausfallen, kann ein DC "
"Backup die Rolle des DC Master dauerhaft übernehmen."

#: umc/js/setup/SystemRolePage.js:103
msgid ""
"<h2>Base system</h2>A base system is an autonomous system which is not a "
"member of the domain.A base system is thus suitable for services which are "

"an, die außerhalb des Vertrauenskontextes der Domäne betrieben werden, etwa "
"als Web-Server oder Firewall."

#: umc/js/setup/SystemRolePage.js:83
msgid ""
"<h2>Master domain controller</h2>A system with the master domain controller "
"role (DC master for short) is the primary domain controller of a UCS domain "

"Sicherheitszertifikategespeichert. Kopien dieser Daten werden automatisch "
"auf Server mit der Rolle Domänencontroller Backup übertragen."

#: umc/js/setup/SystemRolePage.js:98
msgid ""
"<h2>Member server</h2>Member servers are server systems without a local LDAP "
"server. Access to domain data here is performed via other servers in the "

"Server. Der Zugriff auf Domänendaten erfolgt hierbei über andere Server der "
"Domäne."

#: umc/js/setup/SystemRolePage.js:93
msgid ""
"<h2>Slave domain controller</h2>All the domain data are saved as read-only "
"copies on servers with the slave domain controller role (slave DC for "

"lastintensiver Dienste an. Ein DC Slave-System kann nicht zum DC Master "
"hochgestuft werden."

#: umc/js/setup/LanguagePage.js:69
msgid ""
"<i>Language settings</i> incorporate all language relevant configurations, "
"such as time zone, keyboard layout, and system locales."

"Die <i>Spracheinstellungen</i> beinhalten alle sprachrelevanten "
"Einstellungsmöglichkeiten wie Zeitzone, Tastaturlayout und Systemsprache."

#: umc/js/setup/BasisPage.js:101
msgid "A virtual network device cannot be used for DHCP."
msgstr "Ein virtuelles Netzwerkgerät kann nicht für DHCP benutzt werden."

#: umc/js/_setup/BasisPage.js:101
msgid "Access settings"
msgstr "Zugriffseinstellungen"

#: umc/js/setup.js:656
msgid "Account data"
msgstr "Kontodaten"

#: umc/js/setup/InterfaceGrid.js:356
msgid "Add a network interface"
msgstr ""

#: umc/js/setup/InterfaceGrid.js:121 umc/js/setup/InterfaceGrid.js:323
msgid "Add interface"
msgstr "Netzwerkgerät hinzufügen"

#: umc/js/setup.js:281 umc/js/setup.js:600 umc/js/setup.js:680
msgid "Apply changes"
msgstr "Änderungen anwenden"

#: umc/js/setup.js:215
msgid "Apply settings"
msgstr "Einstellungen anwenden"

#: umc/js/setup/InterfaceWizard.js:169
msgid "Autoconfiguration (SLAAC)"
msgstr "Automatische Konfiguration (SLAAC)"

#: umc/js/setup.js:200
msgid "Back"
msgstr "Zurück"

#: umc/js/setup/SystemRolePage.js:77
msgid "Base system"
msgstr "Basissystem"

#: umc/js/setup/BasisPage.js:67
msgid "Basic settings"
msgstr "Basis-Einstellungen"

#: umc/js/setup/types.js:47
msgid "Bonding"
msgstr ""

#: umc/js/setup/InterfaceWizard.js:238
msgid "Bonding configuration"
msgstr "Bonding konfiguration"

#: umc/js/setup/types.js:48
msgid "Bridge"
msgstr ""

#: umc/js/setup/InterfaceWizard.js:213
msgid "Bridge configuration"
msgstr "Bridge konfiguration"

#: umc/js/setup/CertificatePage.js:104
msgid "Business unit"
msgstr "Abteilung"

#: umc/js/setup.js:275 umc/js/setup.js:388 umc/js/setup.js:597
#: umc/js/setup.js:644 umc/js/setup.js:676 umc/js/setup/InterfaceGrid.js:138
#: umc/js/setup/BasisPage.js:256
msgid "Cancel"
msgstr "Abbrechen"

#: umc/js/setup/LanguagePage.js:111
msgid "Category"
msgstr "Kategorie"

#: umc/js/setup/CertificatePage.js:68
msgid "Certificate"
msgstr "Zertifikat"

#: umc/js/setup/CertificatePage.js:69
msgid "Certificate settings"
msgstr "Zertifikateinstellungen"

#: umc/js/setup/CertificatePage.js:148
msgid ""
"Changes in the SSL certificate settings will result in generating new root "
"SSL certificates. Note that this will require an update of all host "

"univention.de/1000\" target=\"_blank\">Univention Support Database</a> "
"gefunden werden."

#: umc/js/setup/NetworkPage.js:153
msgid ""
"Changing IP address configurations may result in restarting or stopping "
"services. This can have severe side-effects when the system is in productive "

"zur Folge haben. Dies kann ernsthafte Auswirkungen haben, sollte sich das "
"System im Produktiveinsatz befinden."

#: umc/js/setup.js:266 umc/js/setup.js:270
msgid "Close"
msgstr "Schließen"

#: umc/js/setup/CertificatePage.js:80
msgid "Common name for the root SSL certificate"
msgstr "Allgemeiner Name (common name) für das Root-SSL-Zertifikat"

#: umc/js/setup.js:725
msgid "Configuration finished"
msgstr "Konfiguration abgeschlossen"

#: umc/js/setup/SystemRolePage.js:107
msgid "Configuration of the UCS system role"
msgstr "Konfiguration der UCS-Systemrolle"

#: umc/js/setup/InterfaceWizard.js:90 umc/js/setup/InterfaceWizard.js:214
#: umc/js/setup/InterfaceWizard.js:239
#, python-format
msgid "Configure the %s network interface %s"
msgstr ""

#: umc/js/setup.js:391 umc/js/setup/BasisPage.js:260
msgid "Continue"
msgstr "Fortfahren"

#: umc/js/setup.js:792
msgid "Continue unjoined"
msgstr "Ungejoint fortfahren"

#: umc/js/setup/CertificatePage.js:86
msgid "Country"
msgstr "Land"

#: umc/js/setup/LanguagePage.js:117
msgid "Country code"
msgstr "Ländercode"

#: umc/js/setup/SystemRolePage.js:71
msgid "Currently selected system role"
msgstr "Aktuell ausgewählte Systemrolle"

#: umc/js/setup/InterfaceWizard.js:438 umc/js/setup/InterfaceWizard.js:450
msgid "DHCP query failed."
msgstr "DHCP-Anfrage schlug fehl."

#: umc/js/setup/LanguagePage.js:140 umc/js/setup/LanguagePage.js:235
msgid "Default system locale"
msgstr "Standard-System-Sprachdefinition"

#: umc/js/setup/InterfaceGrid.js:129 umc/js/setup/InterfaceGrid.js:135
msgid "Delete"
msgstr ""

#: umc/js/setup/SystemRolePage.js:74
msgid "Domain controller backup"
msgstr "Domänencontroller Backup"

#: umc/js/setup/SystemRolePage.js:73
msgid "Domain controller master"
msgstr "Domänencontroller Master"

#: umc/js/setup/SystemRolePage.js:75
msgid "Domain controller slave"
msgstr "Domänencontroller Slave"

#: umc/js/setup/NetworkPage.js:489
msgid "Domain name server"
msgstr "Domänen-DNS-Server"

#: umc/js/setup/NetworkPage.js:119
msgid "Domain name server (max. 3)"
msgstr "Domänen-DNS-Server (max. 3)"

#: umc/js/setup/InterfaceWizard.js:143
msgid "Dynamic (DHCP)"
msgstr "Dynamisch (DHCP)"

#: umc/js/setup/InterfaceGrid.js:113
msgid "Edit"
msgstr ""

#: umc/js/setup/InterfaceGrid.js:356
msgid "Edit a network interface"
msgstr ""

#: umc/js/setup/CertificatePage.js:108
msgid "Email address"
msgstr "E-Mailadresse"

#: umc/js/setup/types.js:45
msgid "Ethernet"
msgstr ""

#: umc/js/setup/NetworkPage.js:493
msgid "External name server"
msgstr "Externer DNS-Server "

#: umc/js/setup/NetworkPage.js:125
msgid "External name server (max. 3)"
msgstr "Externer DNS-Server "

#: umc/js/setup/CertificatePage.js:70
msgid ""
"Following the <i>certificate settings</i>, a new root certificate will be "
"created for the domain. Note that this step only applies to systems with the "

"Zertifikat für die Domäne erstellt. Hinweis: Dieser Schritt ist nur auf "
"Domänencontroller Master-Systemen notwendig."

#: umc/js/setup/BasisPage.js:125
msgid ""
"For Active Directory domains the fully qualified domain name must have at "
"least two dots (e.g. host.example.com). This warning is shown only once, the "

"Warnung, die Einstellungen können mit dem aktuell gewählten Namen "
"gespeichert werden."

#: umc/js/setup/BasisPage.js:212
msgid "Fully qualified domain name"
msgstr "Vollständiger Rechnername"

#: umc/js/setup/BasisPage.js:77
msgid "Fully qualified domain name (e.g. master.example.com)"
msgstr "Vollständiger Rechnername (z.B. master.example.com)"

#: umc/js/setup/NetworkPage.js:110 umc/js/setup/NetworkPage.js:481
msgid "Gateway (IPv4)"
msgstr "Gateway (IPv4)"

#: umc/js/setup/NetworkPage.js:114 umc/js/setup/NetworkPage.js:485
msgid "Gateway (IPv6)"
msgstr "Gateway (IPv6)"

#: umc/js/setup/BasisPage.js:66
msgid "General"
msgstr "Allgemein"

#: umc/js/setup/CertificatePage.js:112
msgid "General settings"
msgstr "Allgemeine Einstellungen"

#: umc/js/setup/InterfaceWizard.js:207 umc/js/setup/NetworkPage.js:137
msgid "Global network settings"
msgstr "Globale Netzwerk-Einstellungen"

#: umc/js/setup/NetworkPage.js:130 umc/js/setup/NetworkPage.js:497
msgid "HTTP proxy"
msgstr "HTTP-Proxy"

#: umc/js/setup/HelpPage.js:60
msgid "Help"
msgstr "Hilfe"

#: umc/js/setup/BasisPage.js:98
msgid "Host and domain settings"
msgstr "Rechner- und Domänen-Einstellungen"

#: umc/js/setup/BasisPage.js:240
msgid "Hostname and windows domain may not be equal."
msgstr "Hostname und Windows-Domäne dürfen nicht gleich sein."

#: umc/js/setup/InterfaceGrid.js:81
msgid "IP addresses"
msgstr "IP-Adressen"

#: umc/js/setup/NetworkPage.js:134
msgid "IP network devices"
msgstr "IP Netzwerkgeräte"

#: umc/js/setup/InterfaceWizard.js:130
msgid "IPv4 address"
msgstr "IPv4-Adresse"

#: umc/js/setup/InterfaceWizard.js:201 umc/js/setup/NetworkPage.js:501
msgid "IPv4 network devices"
msgstr "IPv4-Netzwerkgeräte"

#: umc/js/setup/InterfaceWizard.js:151
msgid "IPv6 address"
msgstr "IPv6-Adresse"

#: umc/js/setup/NetworkPage.js:514
msgid "IPv6 interfaces with autoconfiguration (SLAAC)"
msgstr "IPv6-Netzwerkgeräte mit automatische Konfiguration (SLAAC)"

#: umc/js/setup/InterfaceWizard.js:204 umc/js/setup/NetworkPage.js:505
msgid "IPv6 network devices"
msgstr "IPv6-Netzwerkgeräte"

#: umc/js/setup/InterfaceWizard.js:155
msgid "IPv6 prefix"
msgstr "IPv6-Präfix"

#: umc/js/setup/InterfaceWizard.js:159
msgid "Identifier"
msgstr "Bezeichner"

#: umc/js/setup/BasisPage.js:245
msgid ""
"If Samba is used on this system, the length of the hostname may be at most "
"13 characters."
msgstr ""
"Falls Samba auf diesem System verwendet wird, darf der Hostname maximal 13 "
"Zeichen lang sein."

#: umc/js/setup/SystemRolePage.js:62
msgid ""
"If the system is not part of a domain yet, the <i>system role</i> may be "
"changed."

"Die <i>Systemrolle</i> des Systems kann geändert werden, solange es noch "
"nicht der UCS-Domäne beigetreten ist."

#: umc/js/setup/NetworkPage.js:80
msgid ""
"In the <i>network settings</i>, IP addresses (IPv4 and IPv6) as well as name "
"servers, gateways, and HTTP proxies may be specified."

"In den <i>Netzwerkeinstellungen</i> können IP-Adressen (IPv4 und IPv6) sowie "
"DNS-Server, Gateways und HTTP-Proxy festgelegt werden."

#: umc/js/setup/InterfaceGrid.js:73
msgid "Information"
msgstr "Informationen"

#: umc/js/setup/HelpPage.js:82
msgid "Information about the initial configuration"
msgstr "Informationen über die Erstkonfiguration"

#: umc/js/setup.js:700
msgid "Initialize the configuration process ..."
msgstr "Initialisiere den Konfigurationsvorgang ..."

#: umc/js/setup/SoftwarePage.js:86
msgid "Installation of software components"
msgstr "Installation von Softwarekomponenten"

#: umc/js/setup/SoftwarePage.js:76
msgid "Installed software components"
msgstr "Installierte Softwarekomponenten"

#: umc/js/setup/LanguagePage.js:102 umc/js/setup/LanguagePage.js:231
msgid "Installed system locales"
msgstr "Verfügbare System-Lokalisierungen"

#: umc/js/setup/SoftwarePage.js:119
msgid ""
"Installing or removing software components may result in restarting or "
"stopping services. This can have severe side-effects when the system is in "

"oder Anhalten von diversen Diensten zur Folge haben. Dies kann ernsthafte "
"Auswirkungen haben, sollte sich das System im Produktiveinsatz befinden."

#: umc/js/setup/SoftwarePage.js:223
msgid "Installing software components"
msgstr "Installation von Softwarekomponenten"

#: umc/js/setup/InterfaceGrid.js:62 umc/js/setup/InterfaceGrid.js:280
#: umc/js/setup/InterfaceWizard.js:104
msgid "Interface"
msgstr "Netzwerkgerät"

#: umc/js/setup/InterfaceGrid.js:217
#, python-format
msgid "Interface \"%s\" already exists"
msgstr ""

#: umc/js/setup/InterfaceWizard.js:89
msgid "Interface configuration"
msgstr "Netzwerkgerätekonfiguration"

#: umc/js/setup/InterfaceGrid.js:245
msgid "Interface type"
msgstr "Netzwerkgerätetyp"

#: umc/js/setup/InterfaceGrid.js:94
msgid "Interfaces"
msgstr "Netzwerkgeräte"

#: umc/js/setup/SoftwarePage.js:118
msgid ""
"It is not possible to mix NT and Active Directory compatible "
"domaincontroller. Make sure the existing UCS domain is Active Directory-"

"gleichzeitig zu verwenden. Stellen sie sicher, dass die existierende UCS-"
"Domäne kompatibel zu Active-Directory (Samba 4) ist."

#: umc/js/setup/SoftwarePage.js:117
msgid ""
"It is not possible to mix NT and Active Directory compatible "
"domaincontroller. Make sure the existing UCS domain is NT-compatible (Samba "

"gleichzeitig zu verwenden. Stellen sie sicher, dass die existierende UCS-"
"Domäne NT-kompatibel (Samba 3) ist."

#: umc/js/setup.js:631
msgid "Join"
msgstr "Join"

#: umc/js/setup/LanguagePage.js:91 umc/js/setup/LanguagePage.js:227
msgid "Keyboard layout"
msgstr "Tastaturlayout"

#: umc/js/setup/BasisPage.js:82 umc/js/setup/BasisPage.js:216
msgid "LDAP base"
msgstr "LDAP-Basis"

#: umc/js/setup/LanguagePage.js:67 umc/js/setup/LanguagePage.js:115
msgid "Language"
msgstr "Sprache"

#: umc/js/setup/LanguagePage.js:114
msgid "Language (english)"
msgstr "Sprache (englisch)"

#: umc/js/setup/LanguagePage.js:116
msgid "Language code"
msgstr "Sprachcode"

#: umc/js/setup/LanguagePage.js:68 umc/js/setup/LanguagePage.js:152
msgid "Language settings"
msgstr "Spracheinstellungen"

#: umc/js/setup/CertificatePage.js:96
msgid "Location"
msgstr "Ort"

#: umc/js/setup/CertificatePage.js:115
msgid "Location settings"
msgstr "Standorteinstellungen"

#: umc/js/setup/SystemRolePage.js:76
msgid "Member server"
msgstr "Member-Server"

#: umc/js/setup/InterfaceWizard.js:258
msgid "Mode"
msgstr ""

#: umc/js/setup/LanguagePage.js:123
msgid "Name"
msgstr "Name"

#: umc/js/setup/InterfaceWizard.js:134
msgid "Netmask"
msgstr "Netzmaske"

#: umc/js/setup/NetworkPage.js:78
msgid "Network"
msgstr "Netzwerk"

#: umc/js/setup/NetworkPage.js:79
msgid "Network settings"
msgstr "Netzwerk-Einstellungen"

#: umc/js/setup/BasisPage.js:224
msgid "New root password"
msgstr "Neues Root-Passwort"

#: umc/js/setup.js:182
msgid "Next"
msgstr "Vor"

#: umc/js/setup.js:513
msgid "No changes have been made."
msgstr "Es wurden keine Änderungen vorgenommen."

#: umc/js/setup/NetworkPage.js:515
msgid "No device"
msgstr "Kein Gerät"

#: umc/js/setup.js:747
msgid "Not all changes could be applied successfully:"
msgstr "Nicht alle Änderungen konnten erfolgreich übernommen werden."

#: umc/js/setup.js:751
msgid "Ok"
msgstr "Ok"

#: umc/js/setup/CertificatePage.js:100
msgid "Organization"
msgstr "Organisation"

#: umc/js/setup/CertificatePage.js:118
msgid "Organization settings"
msgstr "Einstellungen über die Organisation"

#: umc/js/setup.js:627
msgid "Password"
msgstr "Passwort"

#: umc/js/setup/InterfaceWizard.js:425
msgid "Please choose a network device before querying a DHCP address."
msgstr ""
"Bitte wählen Sie ein Netzwerkgerät bevor Sie eine DHCP-Adresse anfragen."

#: umc/js/setup/InterfaceGrid.js:134
#, python-format
msgid "Please confirm the removal of the %d selected interfaces!"
msgstr ""

#: umc/js/setup.js:592
msgid ""
"Please confirm to apply these changes to the system. This may take some time."
msgstr ""
"Bitte bestätigen Sie, dass diese Änderungen auf das System übertragen "
"werden. Dies kann einige Zeit in Anspruch nehmen."

#: umc/js/setup.js:792
msgid "Reconfigure, retry"
msgstr "Ändern, wiederholen"

#: umc/js/setup/SoftwarePage.js:233
msgid "Removing software components"
msgstr "Entfernen von Softwarekomponenten"

#: umc/js/setup.js:287
msgid "Reset"
msgstr "Zurücksetzen"

#: umc/js/setup/BasisPage.js:94
msgid "Root password"
msgstr "Root-Passwort"

#: umc/js/setup/BasisPage.js:250
msgid "Root password empty. Continue?"
msgstr "Root-Passwort ist leer. Möchten Sie fortfahren?"

#: umc/js/setup/CertificatePage.js:190
msgid "SSL root certificate"
msgstr "SSL-Root-Zertifikat"

#: umc/js/setup/InterfaceGrid.js:314 umc/js/setup/InterfaceGrid.js:322
msgid "Select an interface type"
msgstr "Auswahl des Netzwerkgerätetyp"

#: umc/js/setup.js:269
msgid "Should the UMC module be closed? All unsaved modification will be lost."
msgstr ""
"Soll das UMC-Modul geschlossen werden? Alle nicht gespeicherten Änderungen "
"gehen verloren"

#: umc/js/setup/SoftwarePage.js:65
msgid "Software"
msgstr "Software"

#: umc/js/setup/SoftwarePage.js:66
msgid "Software settings"
msgstr "Software-Einstellungen"

#: umc/js/setup/CertificatePage.js:92
msgid "State"
msgstr "Bundesland"

#: umc/js/setup/SystemRolePage.js:60 umc/js/setup/SystemRolePage.js:61
#: umc/js/setup/SystemRolePage.js:170
msgid "System role"
msgstr "Systemrolle"

#: umc/js/setup/BasisPage.js:68
msgid ""
"The <i>basic settings</i> define essential properties, such as host and "
"domain name, LDAP base, Windows domain name as well as the system "

"und Domänenname, LDAP-Basis, Windows-Domänename und das Passwort für die "
"Systemadministration (root) fest. "

#: umc/js/setup.js:735 umc/js/setup.js:741
msgid "The changes have been applied successfully."
msgstr "Die Änderungen wurden erfolgreich übernommen."

#: umc/js/setup.js:786
msgid ""
"The configuration was successful. Please confirm to complete the process."
msgstr ""
"Die Konfiguration war erfolgreich. Bitte bestätigen Sie, um den Vorgang "
"abzuschließen."

#: umc/js/setup.js:720
msgid ""
"The connection to the server could not be established after {time} seconds. "
"This problem can occur due to a change of the IP address. In this case, "

"führen sein. Loggen Sie sich in diesem Fall erneut auf Univention Management "
"Console unter der {linkStart}neuen Adresse{linkEnd} ein."

#: umc/js/setup/InterfaceWizard.js:387
msgid "The entered data is not valid. Please correct your input."
msgstr ""

#: umc/js/setup.js:586
msgid "The following changes will be applied to the system:"
msgstr "Die folgenden Änderungen werden auf das System übertragen:"

#: umc/js/setup.js:523
msgid "The following entries could not be validated:"
msgstr "Die folgenden Einträge konnte nicht validiert werden:"

#: umc/js/setup/InterfaceGrid.js:304
msgid "The interface must be one of the physical interfaces: "
msgstr ""

#: umc/js/setup.js:797
msgid ""
"The settings can be changed in the UMC module \"Basic settings\" after the "
"join process has been completed. Please confirm now to complete the process."

"\"Basis-Einstellungen\" geändert werden. Bitte bestätigen Sie, um den "
"Vorgang abzuschließen."

#: umc/js/setup.js:612
msgid ""
"The specified settings will be applied to the system and the system will be "
"joined into the domain. Please enter username and password of a domain "

"das System der Domäne beitreten. Bitte geben Sie dafür Benutzernamen und "
"Password eines Administrator-Kontos der Domäne an."

#: umc/js/setup.js:673
msgid ""
"The specified settings will be applied to the system. This may take some "
"time. Please confirm to proceed."

"Die angegebenen Einstellungen werden auf das System übertragen, dies kann "
"einen Moment dauern. Bitte bestätigen Sie um fortzufahren."

#: umc/js/setup.js:789
msgid "The system join was not successful."
msgstr "Der Domänenbeitritt war nicht erfolgreich."

#: umc/js/setup.js:795
msgid ""
"The system join was successful, however, errors occurred while applying the "
"configuration settings:"

"Der Domänenbeitritt war erfolgreich, allerdings sind Fehler beim Setzen der "
"Konfigurationseinstellungen aufgetreten:"

#: umc/js/setup/InterfaceGrid.js:307
msgid ""
"There must be at least two physical interfaces to use a bonding interface"
msgstr ""

#: umc/js/setup/LanguagePage.js:85 umc/js/setup/LanguagePage.js:223
msgid "Time zone"
msgstr "Zeitzone"

#: umc/js/setup/LanguagePage.js:149
msgid "Time zone and keyboard settings"
msgstr "Zeitzonen- und Tastatureinstellungen"

#: umc/js/setup/InterfaceGrid.js:66
msgid "Type"
msgstr ""

#: umc/js/setup/HelpPage.js:61
msgid "UCS initial configuration"
msgstr "UCS Erstkonfiguration"

#: umc/js/setup.js:623
msgid "Username"
msgstr "Benutzername"

#: umc/js/setup/SoftwarePage.js:67
msgid ""
"Via the <i>software settings</i>, particular software components may be "
"installed or removed."

"Über die <i>Software-Einstellungen</i> können bestimmte Software-Komponenten "
"installiert und deinstalliert werden."

#: umc/js/setup/types.js:46
msgid "Virtual LAN"
msgstr "virtuelles LAN"

#: umc/js/setup/InterfaceWizard.js:181
msgid "Virtual interface ID"
msgstr "virtuelle Geräte ID"

#: umc/js/setup/BasisPage.js:88 umc/js/setup/BasisPage.js:220
msgid "Windows domain"
msgstr "Windows-Domäne"

#: umc/js/setup/InterfaceWizard.js:367
msgid ""
"You have to specify a valid interface and interfaceType. Please correct your "
"input."
msgstr ""

#: umc/js/setup/InterfaceWizard.js:373
msgid "You have to specify at least one ip address or enable DHCP or SLACC."
msgstr ""

#: umc/js/setup/InterfaceWizard.js:377
msgid "You have to specify at least two interfaces to use for this bond device"
msgstr ""

#: umc/js/setup.js:791
msgid ""
"You may return, reconfigure the settings, and retry the join process. You "
"may also continue and end the wizard leaving the system unjoined. The system "
"can be joined later via the UMC module \"Domain join\"."

"System ist dann nicht Teil der Domäne. Sie können es zu einem späteren "
"Zeitpunkt mit dem UMC-Modul \"Domänenbeitritt\" hinzufügen."

#: umc/js/setup/InterfaceWizard.js:287
msgid "advanced configuration"
msgstr "erweiterte Konfiguration"

#: umc/js/setup/InterfaceWizard.js:284
msgid "configure the bonding interface"
msgstr ""

#: umc/js/setup/InterfaceWizard.js:231
msgid "configure the bridge interface"
msgstr ""

#: umc/js/setup/InterfaceWizard.js:174
msgid "enable Virtual LAN"
msgstr "virtuelles LAN aktivieren"

#: umc/js/setup/InterfaceWizard.js:242
msgid "physical interfaces used for the bonding interface"
msgstr ""

#: umc/js/setup/NetworkPage.js:98 umc/js/setup/NetworkPage.js:509
msgid "primary network interface"
msgstr ""

#~ msgid ""
#~ "<h2>Base system</h2>A base system is an independent system. It is not a "
#~ "member of a domain and does not maintain trust relationships with other "

#~ "wird nur das eigene und das öffentliche SSL-Zertifikat der Root-CA "
#~ "vorgehalten."

#~ msgid "A virtual network device cannot be used for DHCP."
#~ msgstr "Ein virtuelles Netzwerkgerät kann nicht für DHCP benutzt werden."

#~ msgid "Activated"
#~ msgstr "Aktiviert"


#~ msgstr ""
#~ "Ihre Session sollte automatisch beendet werden. Ist dies nicht der Fall, "
#~ "kann das Beenden mittels der Tastenkombination Ctrl+Q forciert werden."

#~ msgid "advanced configuration"
#~ msgstr "Erweiterte Konfiguration"

#~ msgid "virtual"
#~ msgstr "virtuell"

(-)umc/js/setup.js (-1 / +1 lines)

Lines 340-346	Link Here

340

341

		setValues: function(values) {

341

		setValues: function(values) {

342

			// update all pages with the given values

342

			// update all pages with the given values

343

			this._orgValues = lang.clone(values);

343

			this._orgValues = lang.clone(values); //FIXME: wrong place

344

			array.forEach(this._pages, function(ipage) {

344

			array.forEach(this._pages, function(ipage) {

345

				ipage.setValues(this._orgValues);

345

				ipage.setValues(this._orgValues);

346

			}, this);

346

			}, this);




import apt
import psutil
import csv
import imp

from univention.lib.i18n import Translation
from univention.management.console.log import MODULE

if not '/lib/univention-installer/' in sys.path:
	sys.path.append('/lib/univention-installer/')
import package_list
import imp

ucr=univention.config_registry.ConfigRegistry()
ucr.load()

	'proxy/http',
	# net: ipv6
	'ipv6/gateway',
	'interfaces/primary',
	# ssl
	'ssl/common', 'ssl/locality', 'ssl/country', 'ssl/state',
	'ssl/organization', 'ssl/organizationalunit', 'ssl/email',

	for link_local in link_locals:
		net_values['interfaces/%s/type' % link_local] = 'dhcp'
	values.update(net_values)
	values['interfaces'] = [idev['name'] for idev in detect_interfaces()]

	# see whether the system has been joined or not
	values['joined'] = os.path.exists('/var/univention-join/joined')

Return to bug 28389