You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
595 lines
18 KiB
595 lines
18 KiB
#-*- coding: utf-8 -*-
|
|
|
|
# Copyright 2008-2012 Calculate Ltd. http://www.calculate-linux.org
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import os
|
|
import sys
|
|
import re
|
|
from os import path
|
|
from calculate.lib.datavars import Variable,VariableError,ReadonlyVariable, \
|
|
READONLY
|
|
|
|
from calculate.lib.cl_lang import setLocalTranslate
|
|
setLocalTranslate('cl_install',sys.modules[__name__])
|
|
|
|
from calculate.lib.utils.ip import (getInterfaces,getIp,getMask,getMac,
|
|
cidrToMask,maskToCidr,getIpNet,isDhcpIp,checkIp,checkMask)
|
|
from calculate.lib.utils.device import lspci
|
|
from calculate.lib.utils.files import listDirectory,readLinesFile
|
|
from calculate.lib.utils import ip
|
|
from calculate.lib.utils.portage import isPkgInstalled
|
|
|
|
class FieldValue:
|
|
"""
|
|
Table column variable
|
|
"""
|
|
type = "list"
|
|
source_variable = ""
|
|
column = 0
|
|
|
|
def get(self):
|
|
sourceVar = self.Get(self.source_variable)
|
|
if any(sourceVar):
|
|
return zip(*sourceVar)[self.column]
|
|
else:
|
|
return []
|
|
|
|
class NetVariable(Variable):
|
|
"""
|
|
Network variables not using for flash installation
|
|
"""
|
|
def uncompatible(self):
|
|
"""
|
|
Network setting up unavailable for flash installation
|
|
"""
|
|
if self.Get('os_install_root_type') == 'flash':
|
|
return \
|
|
_("Network configuration unavailable for flash installation")
|
|
return ""
|
|
|
|
class VariableOsInstallNtp(NetVariable):
|
|
"""
|
|
NTP server for system
|
|
"""
|
|
opt = ['--ntp']
|
|
metavalue = "NTP"
|
|
value = "ntp0.zenon.net"
|
|
|
|
def init(self):
|
|
self.label = _("NTP server")
|
|
self.help = _("set the ntp server for the system")
|
|
|
|
class VariableOsInstallProxy(NetVariable):
|
|
"""
|
|
Proxy for system
|
|
"""
|
|
value = ""
|
|
|
|
class VariableOsInstallNetInterfaces(NetVariable):
|
|
"""
|
|
Net interface devices
|
|
"""
|
|
type = "list"
|
|
mode = READONLY
|
|
|
|
def init(self):
|
|
self.label = _("Interface")
|
|
|
|
def get(self):
|
|
return getInterfaces()
|
|
|
|
|
|
class VariableOsNetInterfacesInfo(NetVariable):
|
|
"""
|
|
Inforamation about net interfaces
|
|
"""
|
|
def get(self):
|
|
netInterfaces=self.Get("os_net_interfaces")
|
|
listInterfacesInfo = []
|
|
# Получена ли сеть по DHCP если нет to ip или off
|
|
for interface,ipaddr,dhcp in zip(self.Get('os_install_net_interfaces'),
|
|
self.Get('os_install_net_ip'),
|
|
self.Get('os_install_net_dhcp_set')):
|
|
if dhcp == "on":
|
|
listInterfacesInfo.append((interface, _("DHCP")))
|
|
else:
|
|
listInterfacesInfo.append((interface,
|
|
ipaddr if ipaddr else _("Off")))
|
|
return ", ".join(map(lambda x:"%s (%s)"%(x[0],x[1]),
|
|
listInterfacesInfo))
|
|
|
|
|
|
class VariableOsInstallNetData(NetVariable):
|
|
"""
|
|
Hash for information about net
|
|
"""
|
|
type = "table"
|
|
opt = ["--ip"]
|
|
metavalue = "IFACE:IP:MASK"
|
|
source = ["os_install_net_interfaces",
|
|
"os_install_net_dhcp_set",
|
|
"os_install_net_ip",
|
|
"os_install_net_mask",
|
|
"os_install_net_name",
|
|
"os_install_net_mac"]
|
|
|
|
def init(self):
|
|
self.label = _("Addresses")
|
|
self.help = _("ip address with net (example:%s)")%"192.168.1.1/24"
|
|
|
|
class VariableOsInstallNetHostname(NetVariable):
|
|
"""
|
|
Computer hostname
|
|
"""
|
|
def get(self):
|
|
return self.Get('os_install_net_fqdn').partition('.')[0]
|
|
|
|
class VariableOsInstallNetFqdn(NetVariable):
|
|
"""
|
|
Full host name
|
|
"""
|
|
opt = ['--hostname']
|
|
|
|
def init(self):
|
|
self.label = _("Hostname")
|
|
self.help = _("set the short hostname or full hostname")
|
|
|
|
def set(self,value):
|
|
if "." in value:
|
|
return value
|
|
else:
|
|
return "%s.%s"%(value,self.Get('os_install_net_domain'))
|
|
|
|
def check(self,value):
|
|
maxfqdn = 254
|
|
if len(value) > maxfqdn:
|
|
raise VariableError(
|
|
_("Hostname length should be less that %d")%maxfqdn)
|
|
|
|
def get(self):
|
|
return self.Get('os_net_fqdn')
|
|
|
|
class VariableOsInstallNetDomain(NetVariable):
|
|
"""
|
|
Domain on install system
|
|
"""
|
|
def get(self):
|
|
return self.Get('os_install_net_fqdn').partition('.')[2]
|
|
|
|
|
|
class VariableOsInstallNetAllow(NetVariable):
|
|
"""
|
|
Allowed network
|
|
"""
|
|
def get(self):
|
|
"""Allowed network"""
|
|
return self.Get("os_net_allow")
|
|
|
|
class VariableOsInstallNetName(NetVariable):
|
|
"""
|
|
Net device names
|
|
"""
|
|
type = "list"
|
|
mode = READONLY
|
|
|
|
def init(self):
|
|
self.label = _("Name")
|
|
|
|
def get(self):
|
|
rePci = re.compile(r"(\d\d:\d\d\.\d)(?:/[^/]+){2}$")
|
|
def getPci(interface):
|
|
pathname = path.realpath(path.join('/sys/class/net',
|
|
interface))
|
|
pci = rePci.search(pathname)
|
|
if pci:
|
|
return pci.group(1)
|
|
else:
|
|
return ""
|
|
pciEthernet = lspci(shortInfo=True)
|
|
return map(lambda x:"{vendor} {name}".format(**x),
|
|
map(lambda x:pciEthernet.get(getPci(x),
|
|
{'vendor':_("Unknown"),
|
|
'name':_("vendor")}),
|
|
self.Get('os_install_net_interfaces')))
|
|
|
|
class VariableOsInstallNetMac(NetVariable):
|
|
"""
|
|
Net devices mac (Example: 01:02:03:04:05:06)
|
|
"""
|
|
type = "list"
|
|
mode = READONLY
|
|
|
|
def init(self):
|
|
self.label = _("MAC")
|
|
|
|
def get(self):
|
|
return map(lambda x:getMac(x),
|
|
self.Get('os_install_net_interfaces'))
|
|
|
|
class VariableOsInstallNetIp(NetVariable):
|
|
"""
|
|
IP for all network interfaces
|
|
"""
|
|
type = "list"
|
|
|
|
def init(self):
|
|
self.label = _("IP address")
|
|
|
|
def get(self):
|
|
return map(lambda x:getIp(x),
|
|
self.Get('os_install_net_interfaces'))
|
|
|
|
def check(self,value):
|
|
wrongIp = filter(lambda x:not checkIp(x),value)
|
|
if wrongIp:
|
|
raise VariableError(_("Wrong IP address %s")%wrongIp[0])
|
|
|
|
class VariableOsInstallNetNetwork(NetVariable):
|
|
"""
|
|
Network for ip (Example:192.168.0.0/16)
|
|
"""
|
|
type = "list"
|
|
mode = READONLY
|
|
|
|
def init(self):
|
|
self.label = _("Network")
|
|
|
|
def get(self):
|
|
return map(lambda x:getIpNet(x[0],x[1]) if x[0] else "",
|
|
zip(self.Get('os_install_net_ip'),
|
|
self.Get('os_install_net_mask')))
|
|
|
|
class VariableOsInstallNetCidr(NetVariable):
|
|
"""
|
|
CIDR of interfaces
|
|
"""
|
|
type = "list"
|
|
mode = READONLY
|
|
|
|
def init(self):
|
|
self.label = _("CIDR")
|
|
|
|
def get(self):
|
|
"""
|
|
Get CIDR of ip,net (Example: 24)
|
|
"""
|
|
return map(lambda x:maskToCidr(x),
|
|
self.Get('os_install_net_mask'))
|
|
|
|
class VariableOsInstallNetMask(NetVariable):
|
|
"""
|
|
Net mask of interfaces (Example:255.255.0.0)
|
|
"""
|
|
type = "choiceedit-list"
|
|
|
|
def init(self):
|
|
self.label = _("Mask")
|
|
|
|
def get(self):
|
|
return map(lambda x:cidrToMask(getMask(x)),
|
|
self.Get('os_install_net_interfaces'))
|
|
|
|
def set(self,value):
|
|
"""
|
|
Convert to mask CIDR value
|
|
"""
|
|
def convertCidrToMask(x):
|
|
if x and x.isdigit() and int(x) in range(0,33):
|
|
return cidrToMask(int(x))
|
|
else:
|
|
return x
|
|
res = map(convertCidrToMask,value)
|
|
return res
|
|
|
|
def check(self,value):
|
|
wrongIp = filter(lambda x:not checkMask(x),value)
|
|
if wrongIp:
|
|
raise VariableError(_("Wrong mask %s")%wrongIp[0])
|
|
|
|
def choice(self):
|
|
return ["255.255.255.255",
|
|
"255.255.255.0",
|
|
"255.255.0.0",
|
|
"255.0.0.0",
|
|
"0.0.0.0"]
|
|
|
|
|
|
class VariableOsInstallNetDhcpSet(NetVariable):
|
|
"""
|
|
Describe ip was get by DHCP or manualy
|
|
"""
|
|
type = "bool-list"
|
|
|
|
def init(self):
|
|
self.label = _("DHCP")
|
|
|
|
def get(self):
|
|
return map(lambda x:"on" if isDhcpIp(x) else "off",
|
|
self.Get('os_install_net_interfaces'))
|
|
|
|
def set(self,value):
|
|
"""
|
|
Get method of receiving ip (dhcp on/off)
|
|
"""
|
|
return map(lambda x:("on"
|
|
if isDhcpIp(x[0]) else "off") if x[1] == "auto" else x[1],
|
|
zip(self.Get('os_install_net_interfaces'),
|
|
value))
|
|
|
|
|
|
class VariableOsInstallNetRouteData(NetVariable):
|
|
"""
|
|
Route table data
|
|
"""
|
|
opt = ["--route"]
|
|
metavalue = "NETWORK:[GATEWAY][:DEV[:SOURCE]]"
|
|
type = "table"
|
|
source = ['os_install_net_route_network',
|
|
'os_install_net_route_gw',
|
|
'os_install_net_route_dev',
|
|
'os_install_net_route_src']
|
|
|
|
def init(self):
|
|
self.label = _("Routing")
|
|
self.help = _("add a routing rule")
|
|
|
|
def get(self):
|
|
"""Routing hash"""
|
|
interfaces = self.Get('os_install_net_interfaces')
|
|
interfaces_dhcp = self.Get('os_install_net_dhcp_set')
|
|
staticInterface = \
|
|
map(lambda x:x[0],
|
|
filter(lambda x:x[1] == "off",
|
|
zip(interfaces,interfaces_dhcp)))
|
|
route_data = []
|
|
if staticInterface:
|
|
return map(lambda x:[x[0],
|
|
x[1].get('via',''),
|
|
x[1].get('dev',''),
|
|
x[1].get('src','')],
|
|
ip.getRouteTable(staticInterface))
|
|
return [[]]
|
|
|
|
class VariableOsInstallNetRouteNetwork(FieldValue,NetVariable):
|
|
"""
|
|
Net for route table record
|
|
"""
|
|
type = "choiceedit-list"
|
|
source_variable = "os_install_net_route_data"
|
|
column = 0
|
|
|
|
def init(self):
|
|
self.label = _("Network")
|
|
|
|
def choice(self):
|
|
return ["default"]+self.Get('os_install_net_network')
|
|
|
|
def check(self,value):
|
|
##########################
|
|
# detect duplicate network
|
|
##########################
|
|
dupNetwork = list(set(filter(lambda x:value.count(x)>1,
|
|
value)))
|
|
if dupNetwork:
|
|
raise VariableError(_("Network '%s' is used twice")%dupNetwork[0])
|
|
|
|
class VariableOsInstallNetRouteGw(FieldValue,NetVariable):
|
|
"""
|
|
Gateway for route table record
|
|
"""
|
|
source_variable = "os_install_net_route_data"
|
|
column = 1
|
|
|
|
def init(self):
|
|
self.label = _("Gateway")
|
|
|
|
def check(self,value):
|
|
#############################
|
|
# search unreachable gateways
|
|
#############################
|
|
NET,GW = 0,1
|
|
netsGw = zip(self.Get('os_install_net_route_network'),
|
|
value)
|
|
nets = filter(lambda x:x and x != "default",
|
|
self.Get('os_install_net_route_network'))
|
|
|
|
wrongGws = map(lambda x:x[GW],
|
|
filter(lambda x:not ip.isIpInNet(x[GW],
|
|
*(set(nets) - set(x[NET]))),
|
|
filter(lambda x:x[GW],
|
|
netsGw)))
|
|
if wrongGws:
|
|
raise VariableError(_("Gateways %s is unreachable")%
|
|
(",".join(wrongGws)))
|
|
|
|
class VariableOsInstallNetRouteDev(FieldValue,NetVariable):
|
|
"""
|
|
Device for route table record
|
|
"""
|
|
type = "choice-list"
|
|
source_variable = "os_install_net_route_data"
|
|
column = 2
|
|
|
|
def init(self):
|
|
self.label = _("Interface")
|
|
|
|
def choice(self):
|
|
return self.Get('os_install_net_interfaces')
|
|
|
|
class VariableOsInstallNetRouteSrc(FieldValue,NetVariable):
|
|
"""
|
|
Source ip for route table record
|
|
"""
|
|
type = "choiceedit-list"
|
|
source_variable = "os_install_net_route_data"
|
|
column = 3
|
|
|
|
def init(self):
|
|
self.label = _("Source")
|
|
|
|
def choice(self):
|
|
return [""]+self.Get('os_install_net_ip')
|
|
|
|
def check(self,value):
|
|
ipAddrs = self.Get('os_install_net_ip')
|
|
wrongIps = filter(lambda x: x and not x in ipAddrs,
|
|
value)
|
|
if wrongIps:
|
|
raise VariableError(_("Wrong ip addresse %s in source IP")%
|
|
(",".join(wrongIps)))
|
|
|
|
class VariableOsInstallNetRoute(NetVariable):
|
|
"""
|
|
Data by route for conf.d/net
|
|
"""
|
|
mode = READONLY
|
|
|
|
def performRouteData(self,performFunc):
|
|
routeMatrix = zip(self.Get('os_install_net_route_network'),
|
|
self.Get('os_install_net_route_gw'),
|
|
self.Get('os_install_net_route_dev'),
|
|
self.Get('os_install_net_route_src'))
|
|
DEV,IP,CIDR,NET = 0,1,2,1
|
|
return map(lambda x:performFunc(x[DEV],x[NET],routeMatrix),
|
|
# union ip and mask to ip/net
|
|
map(lambda x:(x[DEV],ip.getIpNet(x[IP],cidr=x[CIDR])),
|
|
filter(lambda x:x[IP] and x[CIDR],
|
|
zip(self.Get('os_install_net_interfaces'),
|
|
self.Get('os_install_net_ip'),
|
|
self.Get('os_install_net_cidr')))))
|
|
|
|
def get(self):
|
|
"""Route info for conf.d/net"""
|
|
def getRouteForInterfaceConf(interface,net,routeMatrix):
|
|
NET,GW,DEV,SRC = 0,1,2,3
|
|
return "\n".join(
|
|
# build string for route from net,gateway,dev and src
|
|
map(lambda x:"{net}{gateway}{src}".format(
|
|
net=x[NET],
|
|
gateway=" via %s"%x[GW] if x[GW] else "",
|
|
src=" src %s"%x[SRC] if x[SRC] else ""),
|
|
# filter by interface and discard direct routes
|
|
# example: for 192.168.1.5/24 discard 192.168.1.0/24 net
|
|
filter(lambda x:interface==x[DEV] and net!=x[NET],routeMatrix)))
|
|
return self.performRouteData(getRouteForInterfaceConf)
|
|
|
|
|
|
class VariableOsInstallNetNmroute(VariableOsInstallNetRoute):
|
|
"""
|
|
Data by route for NetworkManager
|
|
"""
|
|
mode = READONLY
|
|
|
|
def get(self):
|
|
"""Route info for system-connections of NetworkManager"""
|
|
def getRouteForInterfaceNM(interface,net,routeMatrix):
|
|
NET,GW,DEV,SRC = 0,1,2,3
|
|
defaultGw = map(lambda x:"%s;"%x[GW],
|
|
filter(lambda x:interface==x[DEV] and \
|
|
x[NET]=="default",
|
|
routeMatrix))
|
|
return "{0}\n".format(defaultGw[0] if defaultGw else "") + \
|
|
"\n".join(
|
|
# build string for route from net,gateway,dev and src
|
|
map(lambda x:"routes{num}={ip};{cidr};{gateway};0;".format(
|
|
num=x[0]+1,
|
|
ip=x[1][NET].partition('/')[0],
|
|
cidr=x[1][NET].partition('/')[2],
|
|
gateway=x[1][GW] if x[1][GW] else "0.0.0.0"),
|
|
# filter by interface and discard direct routes
|
|
# example: for 192.168.1.5/24 discard 192.168.1.0/24 net
|
|
enumerate(
|
|
filter(lambda x:interface==x[DEV] and net!=x[NET] and \
|
|
x[NET]!="default",routeMatrix))))
|
|
return self.performRouteData(getRouteForInterfaceNM)
|
|
|
|
class VariableOsInstallNetConf(NetVariable):
|
|
"""
|
|
Net setup (networkmanager or openrc)
|
|
"""
|
|
type = "choice"
|
|
opt = ["--netconf"]
|
|
metavalue = "NETMANAGER"
|
|
|
|
def init(self):
|
|
self.label = _("Network manager")
|
|
self.help = _("network manager")
|
|
|
|
def get(self):
|
|
"""Net setup (networkmanager or openrc)"""
|
|
if filter(lambda x:x.lower() == ("networkmanager"),
|
|
listDirectory('/etc/runlevels/boot')+
|
|
listDirectory('/etc/runlevels/default')) \
|
|
or self.Get('os_install_root_type') == "livecd":
|
|
if isPkgInstalled("net-misc/networkmanager",
|
|
prefix=self.Get('cl_chroot_path')):
|
|
return "networkmanager"
|
|
return "openrc"
|
|
|
|
def choice(self):
|
|
mapNetConf = (('networkmanager','net-misc/networkmanager',_("NetworkManager")),
|
|
('openrc','',_('OpenRC')))
|
|
return map(lambda x:(x[0],x[2]),
|
|
filter(lambda x:not x[1] or isPkgInstalled(x[1],
|
|
prefix=self.Get('cl_chroot_path')),
|
|
mapNetConf))
|
|
|
|
class VariableOsInstallNetDnsSearch(NetVariable):
|
|
"""
|
|
Dns search
|
|
"""
|
|
def isDNSByDHCP(self):
|
|
"""
|
|
If first interface get ip by DHCP dns must be DHCP
|
|
"""
|
|
dhcps = self.Get('os_install_net_dhcp_set')
|
|
if dhcps:
|
|
if dhcps[0] == "on":
|
|
return True
|
|
return False
|
|
|
|
def get(self):
|
|
"""Get current name servers"""
|
|
dnsSearch = " ".join(
|
|
map(lambda x:x.strip().partition("search")[2].strip(),
|
|
filter(lambda x:x.lstrip().startswith("search"),
|
|
readLinesFile('/etc/resolv.conf'))))
|
|
return "" if self.isDNSByDHCP() else dnsSearch
|
|
|
|
|
|
class VariableOsInstallNetDns(VariableOsInstallNetDnsSearch):
|
|
"""
|
|
Dns servers
|
|
"""
|
|
type = "list"
|
|
|
|
def get(self):
|
|
dnsIps = filter(ip.checkIp,
|
|
map(lambda x:x.strip().partition("nameserver")[2].strip(),
|
|
filter(lambda x:x.lstrip().startswith("nameserver"),
|
|
readLinesFile('/etc/resolv.conf'))))
|
|
return "" if self.isDNSByDHCP() else dnsIps
|
|
|
|
def check(self,value):
|
|
reIp = re.compile(ip.IP_ADDR)
|
|
if filter(reIp.match,value):
|
|
raise VariableError(_("Wrong DNS IP addresses"))
|
|
|
|
class VariableOsInstallNetSettings(NetVariable):
|
|
"""
|
|
Net service configured
|
|
"""
|
|
value = ""
|