Skip to content

S
slapos.core
Commit b21e68ff authored by Thomas Gambier's avatar Thomas Gambier 🚴🏼
4 Browse files
Options

slapos.core: introduce ipv6_range for each partition

parent 839ac0ef
Hide whitespace changes
Inline Side-by-side
Showing with 239 additions and 84 deletions
slapos.cfg.example
View file @ b21e68ff
...@@ -32,6 +32,7 @@ tap_ipv6 = true ...@@ -32,6 +32,7 @@ tap_ipv6 = true
# You can choose any other local network which does not conflict with your # You can choose any other local network which does not conflict with your
# current machine configuration # current machine configuration
ipv4_local_network = 10.0.0.0/16 ipv4_local_network = 10.0.0.0/16
partition_has_ipv6_range = true
# to enable, change to [firewall] # to enable, change to [firewall]
[disabled-firewall] [disabled-firewall]
......
slapos/format.py
View file @ b21e68ff
...@@ -57,7 +57,7 @@ import six ...@@ -57,7 +57,7 @@ import six
import lxml.etree import lxml.etree
import xml_marshaller.xml_marshaller import xml_marshaller.xml_marshaller
from slapos.util import dumps, mkdir_p, ipv6FromBin, binFromIpv6, lenNetmaskIpv6 from slapos.util import dumps, mkdir_p, ipv6FromBin, binFromIpv6, lenNetmaskIpv6, getPartitionIpv6Addr, getPartitionIpv6Range, getTapIpv6Range, netmaskFromLenIPv6
import slapos.slap as slap import slapos.slap as slap
from slapos import version from slapos import version
from slapos import manager as slapmanager from slapos import manager as slapmanager
...@@ -239,7 +239,7 @@ class Computer(object): ...@@ -239,7 +239,7 @@ class Computer(object):
"""Object representing the computer""" """Object representing the computer"""
def __init__(self, reference, interface=None, addr=None, netmask=None, def __init__(self, reference, interface=None, addr=None, netmask=None,
ipv6_interface=None, software_user='slapsoft', ipv6_interface=None, partition_has_ipv6_range=None, software_user='slapsoft',
tap_gateway_interface=None, tap_ipv6=None, tap_gateway_interface=None, tap_ipv6=None,
instance_root=None, software_root=None, instance_storage_home=None, instance_root=None, software_root=None, instance_storage_home=None,
partition_list=None, config=None): partition_list=None, config=None):
...@@ -256,6 +256,9 @@ class Computer(object): ...@@ -256,6 +256,9 @@ class Computer(object):
self.address = addr self.address = addr
self.netmask = netmask self.netmask = netmask
self.ipv6_interface = ipv6_interface self.ipv6_interface = ipv6_interface
self.partition_has_ipv6_range = partition_has_ipv6_range
print("DEBUG CONF1")
print(self.partition_has_ipv6_range)
  • Jérome Perrin @jerome ·
    Owner

    ah there are more debug print, maybe it was too early to comment about these :)

Please register or sign in to reply
self.software_user = software_user self.software_user = software_user
self.tap_gateway_interface = tap_gateway_interface self.tap_gateway_interface = tap_gateway_interface
self.tap_ipv6 = tap_ipv6 self.tap_ipv6 = tap_ipv6
...@@ -406,7 +409,7 @@ class Computer(object): ...@@ -406,7 +409,7 @@ class Computer(object):
archive.writestr(saved_filename, xml_content, zipfile.ZIP_DEFLATED) archive.writestr(saved_filename, xml_content, zipfile.ZIP_DEFLATED)
@classmethod @classmethod
def load(cls, path_to_xml, reference, ipv6_interface, tap_gateway_interface, def load(cls, path_to_xml, reference, ipv6_interface, partition_has_ipv6_range, tap_gateway_interface,
tap_ipv6, instance_root=None, software_root=None, config=None): tap_ipv6, instance_root=None, software_root=None, config=None):
""" """
Create a computer object from a valid xml file. Create a computer object from a valid xml file.
...@@ -427,6 +430,7 @@ class Computer(object): ...@@ -427,6 +430,7 @@ class Computer(object):
addr=dumped_dict['address'], addr=dumped_dict['address'],
netmask=dumped_dict['netmask'], netmask=dumped_dict['netmask'],
ipv6_interface=ipv6_interface, ipv6_interface=ipv6_interface,
partition_has_ipv6_range=partition_has_ipv6_range,
software_user=dumped_dict.get('software_user', 'slapsoft'), software_user=dumped_dict.get('software_user', 'slapsoft'),
tap_gateway_interface=tap_gateway_interface, tap_gateway_interface=tap_gateway_interface,
tap_ipv6=tap_ipv6, tap_ipv6=tap_ipv6,
...@@ -463,6 +467,7 @@ class Computer(object): ...@@ -463,6 +467,7 @@ class Computer(object):
tun = Tun("slaptun" + str(partition_index), partition_index, partition_amount) tun = Tun("slaptun" + str(partition_index), partition_index, partition_amount)
address_list = partition_dict['address_list'] address_list = partition_dict['address_list']
ipv6_range = partition_dict.get('ipv6_range', {})
external_storage_list = partition_dict.get('external_storage_list', []) external_storage_list = partition_dict.get('external_storage_list', [])
partition = Partition( partition = Partition(
...@@ -470,6 +475,7 @@ class Computer(object): ...@@ -470,6 +475,7 @@ class Computer(object):
path=partition_dict['path'], path=partition_dict['path'],
user=user, user=user,
address_list=address_list, address_list=address_list,
ipv6_range=ipv6_range,
tap=tap, tap=tap,
tun=tun if config.create_tun else None, tun=tun if config.create_tun else None,
external_storage_list=external_storage_list, external_storage_list=external_storage_list,
...@@ -558,7 +564,7 @@ class Computer(object): ...@@ -558,7 +564,7 @@ class Computer(object):
#################### ####################
if alter_network: if alter_network:
if self.address is not None: if self.address is not None:
self.interface.addIPv6Address(self.address, self.netmask) self.interface._addSystemAddress(self.address, self.netmask)
if create_tap and self.tap_gateway_interface: if create_tap and self.tap_gateway_interface:
gateway_addr_dict = getIfaceAddressIPv4(self.tap_gateway_interface) gateway_addr_dict = getIfaceAddressIPv4(self.tap_gateway_interface)
...@@ -567,6 +573,11 @@ class Computer(object): ...@@ -567,6 +573,11 @@ class Computer(object):
len(self.partition_list)) len(self.partition_list))
assert(len(self.partition_list) <= len(tap_address_list)) assert(len(self.partition_list) <= len(tap_address_list))
if self.partition_has_ipv6_range:
print("WITH RANGE")
print(alter_network)
self.interface.allowUseInexistingIpv6Address()
self._speedHackAddAllOldIpsToInterface() self._speedHackAddAllOldIpsToInterface()
try: try:
...@@ -610,12 +621,13 @@ class Computer(object): ...@@ -610,12 +621,13 @@ class Computer(object):
if self.tap_ipv6: if self.tap_ipv6:
if not partition.tap.ipv6_addr: if not partition.tap.ipv6_addr:
# create a new IPv6 randomly for the tap # create a new IPv6 randomly for the tap
ipv6_dict = self.interface.addIPv6Address(tap=partition.tap) ipv6_dict = self.interface.addIPv6Address(partition_index, tap=partition.tap)
partition.tap.ipv6_addr = ipv6_dict['addr'] partition.tap.ipv6_addr = ipv6_dict['addr']
partition.tap.ipv6_netmask = ipv6_dict['netmask'] partition.tap.ipv6_netmask = ipv6_dict['netmask']
else: else:
# make sure the tap has its IPv6 # make sure the tap has its IPv6
self.interface.addIPv6Address( self.interface.addIPv6Address(
partition_index=partition_index,
addr=partition.tap.ipv6_addr, addr=partition.tap.ipv6_addr,
netmask=partition.tap.ipv6_netmask, netmask=partition.tap.ipv6_netmask,
tap=partition.tap) tap=partition.tap)
...@@ -641,43 +653,58 @@ class Computer(object): ...@@ -641,43 +653,58 @@ class Computer(object):
partition.tun.createWithOwner(owner) partition.tun.createWithOwner(owner)
partition.tun.createRoutes() partition.tun.createRoutes()
# Reconstructing partition's address
# There should be two addresses on each Computer Partition:
# * local IPv4, took from slapformat:ipv4_local_network
# * global IPv6
if not partition.address_list:
# generate new addresses
partition.address_list.append(self.interface.addIPv4LocalAddress())
partition.address_list.append(self.interface.addIPv6Address(partition_index))
else:
# regenerate list of addresses
old_partition_address_list = partition.address_list
partition.address_list = []
if len(old_partition_address_list) != 2:
raise ValueError(
'There should be exactly 2 stored addresses. Got: %r' %
(old_partition_address_list,))
if not any(netaddr.valid_ipv6(q['addr'])
for q in old_partition_address_list):
raise ValueError('No valid IPv6 address loaded from XML config')
if not any(netaddr.valid_ipv4(q['addr'])
for q in old_partition_address_list):
raise ValueError('No valid IPv4 address loaded from XML config')
for address in old_partition_address_list:
if netaddr.valid_ipv6(address['addr']):
partition.address_list.append(self.interface.addIPv6Address(
partition_index,
address['addr'],
address['netmask']))
elif netaddr.valid_ipv4(address['addr']):
partition.address_list.append(self.interface.addIPv4LocalAddress(
address['addr']))
else:
# should never happen since there are exactly 1 valid IPv6 and 1
# valid IPv4 in old_partition_address_list
raise ValueError('Address %r is incorrect' % address['addr'])
# Reconstructing partiton's IPv6 range
if self.partition_has_ipv6_range:
if not partition.ipv6_range:
# generate new IPv6 range
partition.ipv6_range = self.interface.generateIPv6Range(partition_index)
else:
if not netaddr.valid_ipv6(partition.ipv6_range['addr']):
raise ValueError('existing IPv6 range %r is incorrect', partition.ipv6_range['addr'])
else:
partition.ipv6_range = {}
# Reconstructing partition's directory # Reconstructing partition's directory
partition.createPath(alter_user) partition.createPath(alter_user)
partition.createExternalPath(alter_user) partition.createExternalPath(alter_user)
# Reconstructing partition's address
# There should be two addresses on each Computer Partition:
# * local IPv4, took from slapformat:ipv4_local_network
# * global IPv6
if not partition.address_list:
# regenerate
partition.address_list.append(self.interface.addIPv4LocalAddress())
partition.address_list.append(self.interface.addIPv6Address())
elif alter_network:
# regenerate list of addresses
old_partition_address_list = partition.address_list
partition.address_list = []
if len(old_partition_address_list) != 2:
raise ValueError(
'There should be exactly 2 stored addresses. Got: %r' %
(old_partition_address_list,))
if not any(netaddr.valid_ipv6(q['addr'])
for q in old_partition_address_list):
raise ValueError('Not valid ipv6 addresses loaded')
if not any(netaddr.valid_ipv4(q['addr'])
for q in old_partition_address_list):
raise ValueError('Not valid ipv6 addresses loaded')
for address in old_partition_address_list:
if netaddr.valid_ipv6(address['addr']):
partition.address_list.append(self.interface.addIPv6Address(
address['addr'],
address['netmask']))
elif netaddr.valid_ipv4(address['addr']):
partition.address_list.append(self.interface.addIPv4LocalAddress(
address['addr']))
else:
raise ValueError('Address %r is incorrect' % address['addr'])
finally: finally:
for manager in self._manager_list: for manager in self._manager_list:
manager.formatTearDown(self) manager.formatTearDown(self)
...@@ -689,13 +716,14 @@ class Partition(object): ...@@ -689,13 +716,14 @@ class Partition(object):
resource_file = ".slapos-resource" resource_file = ".slapos-resource"
def __init__(self, reference, path, user, address_list, def __init__(self, reference, path, user, address_list,
tap, external_storage_list=[], tun=None): ipv6_range, tap, external_storage_list=[], tun=None):
""" """
Attributes: Attributes:
reference: String, the name of the partition. reference: String, the name of the partition.
path: String, the path to the partition folder. path: String, the path to the partition folder.
user: User, the user linked to this partition. user: User, the user linked to this partition.
address_list: List of associated IP addresses. address_list: List of associated IP addresses.
ipv6_range: IPv6 range given to this partiton (dict with 'addr' and 'netmask').
tap: Tap, the tap interface linked to this partition e.g. used as a gateway for kvm tap: Tap, the tap interface linked to this partition e.g. used as a gateway for kvm
tun: Tun interface used for special apps simulating ethernet connections tun: Tun interface used for special apps simulating ethernet connections
external_storage_list: Base path list of folder to format for data storage external_storage_list: Base path list of folder to format for data storage
...@@ -705,12 +733,13 @@ class Partition(object): ...@@ -705,12 +733,13 @@ class Partition(object):
self.path = str(path) self.path = str(path)
self.user = user self.user = user
self.address_list = address_list or [] self.address_list = address_list or []
self.ipv6_range = ipv6_range or {}
self.tap = tap self.tap = tap
self.tun = tun self.tun = tun
self.external_storage_list = [] self.external_storage_list = []
def __getinitargs__(self): def __getinitargs__(self):
return (self.reference, self.path, self.user, self.address_list, self.tap, self.tun) return (self.reference, self.path, self.user, self.address_list, self.ipv6_range, self.tap, self.tun)
def createPath(self, alter_user=True): def createPath(self, alter_user=True):
""" """
...@@ -1068,13 +1097,10 @@ class Interface(object): ...@@ -1068,13 +1097,10 @@ class Interface(object):
for q in netifaces.ifaddresses(interface_name)[af] for q in netifaces.ifaddresses(interface_name)[af]
]: ]:
# add an address # add an address
callAndRead(['ip', 'addr', 'add', address_string, 'dev', interface_name]) code, _ = callAndRead(['ip', 'addr', 'add', address_string, 'dev', interface_name])
# Fake success for local ipv4
if not ipv6:
return True
# wait few moments if code != 0:
return False
time.sleep(2) time.sleep(2)
# Fake success for local ipv4 # Fake success for local ipv4
...@@ -1128,7 +1154,7 @@ class Interface(object): ...@@ -1128,7 +1154,7 @@ class Interface(object):
# confirmed to be configured # confirmed to be configured
return dict(addr=addr, netmask=netmask) return dict(addr=addr, netmask=netmask)
def addIPv6Address(self, addr=None, netmask=None, tap=None): def addIPv6Address(self, partition_index, addr=None, netmask=None, tap=None):
""" """
Adds IPv6 address to interface. Adds IPv6 address to interface.
...@@ -1138,6 +1164,9 @@ class Interface(object): ...@@ -1138,6 +1164,9 @@ class Interface(object):
address. If it is not possible (ex. because network changed), calculate new address. If it is not possible (ex. because network changed), calculate new
address. address.
If tap is specified, tap will get actually an IPv6 range (and not a single
address) 16 bits smaller than the range of the interface.
Args: Args:
addr: Wished address to be added to interface. addr: Wished address to be added to interface.
netmask: Wished netmask to be used. netmask: Wished netmask to be used.
...@@ -1193,38 +1222,65 @@ class Interface(object): ...@@ -1193,38 +1222,65 @@ class Interface(object):
self._logger.warning('Impossible to add old public IPv6 %s. ' self._logger.warning('Impossible to add old public IPv6 %s. '
'Generating new IPv6 address.' % addr) 'Generating new IPv6 address.' % addr)
# Try 10 times to add address, raise in case if not possible address_dict['netmask'] = lenNetmaskIpv6(address_dict['netmask'])
try_num = 10
netmask = address_dict['netmask']
if tap: if tap:
netmask_len = lenNetmaskIpv6(netmask) result_addr = getTapIpv6Range(address_dict, partition_index)
prefix = binFromIpv6(address_dict['addr'])[:netmask_len] else:
netmask_len += 16 result_addr = getPartitionIpv6Addr(address_dict, partition_index)
# we generate a subnetwork for the tap # restore netmask as bitmask
# the subnetwork has 16 bits more than the interface network result_addr['netmask'] = netmaskFromLenIPv6(result_addr['netmask'])
# make sure we have at least 2 IPs in the subnetwork
if netmask_len >= 128:
self._logger.error('Interface %s has netmask %s which is too big for generating IPv6 on taps.' % (interface_name, netmask))
raise AddressGenerationError(addr)
netmask = ipv6FromBin('1'*128) # the netmask of the tap itself is always 128 bits
while try_num > 0: self._addSystemAddress(result_addr['addr'], result_addr['netmask'], tap=tap)
if tap: return result_addr
addr = ipv6FromBin(prefix
+ bin(random.randint(1, 65000))[2:].zfill(16)
+ '1' * (128 - netmask_len))
else:
addr = ':'.join(address_dict['addr'].split(':')[:-1] + ['%x' % (
random.randint(1, 65000), )])
socket.inet_pton(socket.AF_INET6, addr)
if (dict(addr=addr, netmask=netmask) not in
self.getGlobalScopeAddressList(tap=tap)):
# Checking the validity of the IPv6 address
if self._addSystemAddress(addr, netmask, tap=tap):
return dict(addr=addr, netmask=netmask)
try_num -= 1
raise AddressGenerationError(addr) def generateIPv6Range(self, i):
"""
Generate an IPv6 range included in the IPv6 range of the interface. The IPv6 range depends on the partition index i.
There is no need to actually add this range anywhere because allowUseInexistingIpv6Address() has already been called.
Returns:
dict(addr=address, netmask=netmask, network=addr/CIDR).
Raises:
ValueError: Couldn't construct valid address with existing
one's on the interface.
NoAddressOnInterface: There's no address on the interface to construct
an address with.
"""
interface_name = self.ipv6_interface or self.name
# Getting one address of the interface as base of the next addresses
interface_addr_list = self.getGlobalScopeAddressList()
# No address found
if len(interface_addr_list) == 0:
raise NoAddressOnInterface(interface_name)
address_dict = interface_addr_list[0]
address_dict['netmask'] = lenNetmaskIpv6(address_dict['netmask'])
ipv6_range = getPartitionIpv6Range(address_dict, i)
ipv6_range['network'] = '{addr}/{netmask}'.format(**ipv6_range)
ipv6_range['netmask'] = netmaskFromLenIPv6(ipv6_range['netmask'])
return ipv6_range
def allowUseInexistingIpv6Address(self):
# This will allow the usage of unexisting IPv6 adrdresses.
# Getting the global IPv6 range of the computer
interface_addr_list = self.getGlobalScopeAddressList()
# No address found
if len(interface_addr_list) == 0:
raise NoAddressOnInterface(interface_name)
address_dict = interface_addr_list[0]
addr = address_dict['addr']
netmask = address_dict['netmask'].split('/')[1]
self._logger.debug('sysctl net.ipv6.ip_nonlocal_bind=1')
callAndRead(['sysctl', 'net.ipv6.ip_nonlocal_bind=1'])
_, result = callAndRead(['ip', '-6', 'route', 'show', 'table', 'local', '%s/%s' % (addr, netmask)])
if not 'dev lo' in result:
self._logger.debug(' ip -6 route add local %s/%s dev lo', addr, netmask)
callAndRead(['ip', '-6', 'route', 'add', 'local', '%s/%s' % (addr, netmask), 'dev', 'lo'])
def parse_computer_definition(conf, definition_path): def parse_computer_definition(conf, definition_path):
...@@ -1250,6 +1306,7 @@ def parse_computer_definition(conf, definition_path): ...@@ -1250,6 +1306,7 @@ def parse_computer_definition(conf, definition_path):
addr=address, addr=address,
netmask=netmask, netmask=netmask,
ipv6_interface=conf.ipv6_interface, ipv6_interface=conf.ipv6_interface,
partition_has_ipv6_range=conf.partition_has_ipv6_range,
software_user=computer_definition.get('computer', 'software_user'), software_user=computer_definition.get('computer', 'software_user'),
tap_gateway_interface=conf.tap_gateway_interface, tap_gateway_interface=conf.tap_gateway_interface,
tap_ipv6=conf.tap_ipv6, tap_ipv6=conf.tap_ipv6,
...@@ -1264,6 +1321,10 @@ def parse_computer_definition(conf, definition_path): ...@@ -1264,6 +1321,10 @@ def parse_computer_definition(conf, definition_path):
for a in computer_definition.get(section, 'address').split(): for a in computer_definition.get(section, 'address').split():
address, netmask = a.split('/') address, netmask = a.split('/')
address_list.append(dict(addr=address, netmask=netmask)) address_list.append(dict(addr=address, netmask=netmask))
ipv6_range_network = computer_definition.get(section, 'ipv6_range')
addr, netmask = ipv6_range_network.split('/')
netmask = netmaskFromLenIPv6(int(netmask))
ipv6_range = {'addr' : address, 'netmask' : netmask, 'network' : ipv6_range_network}
tap = Tap(computer_definition.get(section, 'network_interface')) tap = Tap(computer_definition.get(section, 'network_interface'))
tun = Tun("slaptun" + str(partition_number), tun = Tun("slaptun" + str(partition_number),
partition_number, partition_number,
...@@ -1273,6 +1334,7 @@ def parse_computer_definition(conf, definition_path): ...@@ -1273,6 +1334,7 @@ def parse_computer_definition(conf, definition_path):
computer_definition.get(section, 'pathname')), computer_definition.get(section, 'pathname')),
user=user, user=user,
address_list=address_list, address_list=address_list,
ipv6_range=ipv6_range,
tap=tap, tun=tun) tap=tap, tun=tun)
partition_list.append(partition) partition_list.append(partition)
computer.partition_list = partition_list computer.partition_list = partition_list
...@@ -1290,6 +1352,7 @@ def parse_computer_xml(conf, xml_path): ...@@ -1290,6 +1352,7 @@ def parse_computer_xml(conf, xml_path):
computer = Computer.load(xml_path, computer = Computer.load(xml_path,
reference=conf.computer_id, reference=conf.computer_id,
ipv6_interface=conf.ipv6_interface, ipv6_interface=conf.ipv6_interface,
partition_has_ipv6_range=conf.partition_has_ipv6_range,
tap_gateway_interface=conf.tap_gateway_interface, tap_gateway_interface=conf.tap_gateway_interface,
tap_ipv6=conf.tap_ipv6, tap_ipv6=conf.tap_ipv6,
software_root=conf.software_root, software_root=conf.software_root,
...@@ -1308,6 +1371,7 @@ def parse_computer_xml(conf, xml_path): ...@@ -1308,6 +1371,7 @@ def parse_computer_xml(conf, xml_path):
addr=None, addr=None,
netmask=None, netmask=None,
ipv6_interface=conf.ipv6_interface, ipv6_interface=conf.ipv6_interface,
partition_has_ipv6_range=conf.partition_has_ipv6_range,
software_user=conf.software_user, software_user=conf.software_user,
tap_gateway_interface=conf.tap_gateway_interface, tap_gateway_interface=conf.tap_gateway_interface,
tap_ipv6=conf.tap_ipv6, tap_ipv6=conf.tap_ipv6,
...@@ -1334,6 +1398,7 @@ def parse_computer_xml(conf, xml_path): ...@@ -1334,6 +1398,7 @@ def parse_computer_xml(conf, xml_path):
conf.partition_base_name, i)), conf.partition_base_name, i)),
user=User('%s%s' % (conf.user_base_name, i)), user=User('%s%s' % (conf.user_base_name, i)),
address_list=None, address_list=None,
ipv6_range=None,
tap=Tap('%s%s' % (conf.tap_base_name, i)), tap=Tap('%s%s' % (conf.tap_base_name, i)),
tun=Tun('slaptun' + str(i), i, partition_amount) if conf.create_tun else None tun=Tun('slaptun' + str(i), i, partition_amount) if conf.create_tun else None
) )
...@@ -1355,6 +1420,7 @@ def write_computer_definition(conf, computer): ...@@ -1355,6 +1420,7 @@ def write_computer_definition(conf, computer):
for address in partition.address_list: for address in partition.address_list:
address_list.append('/'.join([address['addr'], address['netmask']])) address_list.append('/'.join([address['addr'], address['netmask']]))
computer_definition.set(section, 'address', ' '.join(address_list)) computer_definition.set(section, 'address', ' '.join(address_list))
computer_definition.set(section, 'ipv6_range', partition.ipv6_range['network'])
computer_definition.set(section, 'user', partition.user.name) computer_definition.set(section, 'user', partition.user.name)
computer_definition.set(section, 'network_interface', partition.tap.name) computer_definition.set(section, 'network_interface', partition.tap.name)
computer_definition.set(section, 'pathname', partition.reference) computer_definition.set(section, 'pathname', partition.reference)
...@@ -1419,6 +1485,7 @@ class FormatConfig(object): ...@@ -1419,6 +1485,7 @@ class FormatConfig(object):
alter_network = 'True' # modifiable by cmdline alter_network = 'True' # modifiable by cmdline
interface_name = None interface_name = None
ipv6_interface = None ipv6_interface = None
partition_has_ipv6_range = True
create_tap = True create_tap = True
create_tun = False create_tun = False
tap_base_name = None tap_base_name = None
...@@ -1483,7 +1550,7 @@ class FormatConfig(object): ...@@ -1483,7 +1550,7 @@ class FormatConfig(object):
raise UsageError(message) raise UsageError(message)
# Convert strings to booleans # Convert strings to booleans
for option in ['alter_network', 'alter_user', 'create_tap', 'create_tun', 'tap_ipv6']: for option in ['alter_network', 'alter_user', 'partition_has_ipv6_range', 'create_tap', 'create_tun', 'tap_ipv6']:
attr = getattr(self, option) attr = getattr(self, option)
if isinstance(attr, str): if isinstance(attr, str):
if attr.lower() == 'true': if attr.lower() == 'true':
......
slapos/slap/standalone.py
View file @ b21e68ff
...@@ -59,11 +59,23 @@ from .interface.slap import IRequester ...@@ -59,11 +59,23 @@ from .interface.slap import IRequester
from ..grid.slapgrid import SLAPGRID_PROMISE_FAIL from ..grid.slapgrid import SLAPGRID_PROMISE_FAIL
from .slap import slap from .slap import slap
from ..util import dumps, rmtree from ..util import dumps, rmtree, getPartitionIpv6Addr, getPartitionIpv6Range
from ..grid.svcbackend import getSupervisorRPC from ..grid.svcbackend import getSupervisorRPC
from ..grid.svcbackend import _getSupervisordSocketPath from ..grid.svcbackend import _getSupervisordSocketPath
def _getPartitionIpv6(ipv6_address, i):
# returns (single_ipv6_address, ipv6_range) for a partition
# ipv6_address can be either a range or a single IPv6 address (with no /)
if '/' in ipv6_address:
addr,netmask = ipv6_address.split('/')
single_ipv6_address = getPartitionIpv6Addr({'addr':addr, 'netmask':int(netmask)}, i)['addr']
ipv6_range = getPartitionIpv6Range({'addr':addr, 'netmask':int(netmask)}, i)
else:
ipv6_range = None
single_ipv6_address = ipv6_address
return (single_ipv6_address, ipv6_range)
@zope.interface.implementer(IException) @zope.interface.implementer(IException)
class SlapOSNodeCommandError(Exception): class SlapOSNodeCommandError(Exception):
...@@ -287,9 +299,7 @@ class SlapformatDefinitionWriter(ConfigWriter): ...@@ -287,9 +299,7 @@ class SlapformatDefinitionWriter(ConfigWriter):
""" """
def writeConfig(self, path): def writeConfig(self, path):
ipv4 = self._standalone_slapos._ipv4_address ipv4 = self._standalone_slapos._ipv4_address
ipv6 = self._standalone_slapos._ipv6_address
ipv4_cidr = ipv4 + '/255.255.255.255' if ipv4 else '' ipv4_cidr = ipv4 + '/255.255.255.255' if ipv4 else ''
ipv6_cidr = ipv6 + '/64' if ipv6 else ''
user = pwd.getpwuid(os.getuid()).pw_name user = pwd.getpwuid(os.getuid()).pw_name
partition_base_name = self._standalone_slapos._partition_base_name partition_base_name = self._standalone_slapos._partition_base_name
with open(path, 'w') as f: with open(path, 'w') as f:
...@@ -300,11 +310,15 @@ class SlapformatDefinitionWriter(ConfigWriter): ...@@ -300,11 +310,15 @@ class SlapformatDefinitionWriter(ConfigWriter):
address = {ipv4_cidr}\n address = {ipv4_cidr}\n
""").format(**locals())) """).format(**locals()))
for i in range(self._standalone_slapos._partition_count): for i in range(self._standalone_slapos._partition_count):
print(i)
Please register or sign in to reply
single_ipv6_address, ipv6_range = _getPartitionIpv6(self._standalone_slapos._ipv6_address, i)
ipv6_range_network= '{addr}/{netmask}'.format(**ipv6_range)
f.write( f.write(
textwrap.dedent( textwrap.dedent(
""" """
[partition_{i}] [partition_{i}]
address = {ipv6_cidr} {ipv4_cidr} address = {single_ipv6_address}/128 {ipv4_cidr}
ipv6_range = {ipv6_range_network}
pathname = {partition_base_name}{i} pathname = {partition_base_name}{i}
user = {user} user = {user}
network_interface =\n network_interface =\n
...@@ -594,8 +608,12 @@ class StandaloneSlapOS(object): ...@@ -594,8 +608,12 @@ class StandaloneSlapOS(object):
partition_base_name="slappart"): partition_base_name="slappart"):
"""Creates `partition_count` partitions. """Creates `partition_count` partitions.
All partitions have the same `ipv4_address` and `ipv6_address` and All partitions have the same `ipv4_address` and use the current system
use the current system user. user.
`ipv6_address` can be a single address (in this case all partitions have
the same address) or a range in the form IPV6/CIDR (in this case each
partition has a subrange).
When calling this a second time with a lower `partition_count` or with When calling this a second time with a lower `partition_count` or with
different `partition_base_name` will delete existing partitions. different `partition_base_name` will delete existing partitions.
...@@ -628,6 +646,7 @@ class StandaloneSlapOS(object): ...@@ -628,6 +646,7 @@ class StandaloneSlapOS(object):
if not (os.path.exists(partition_path)): if not (os.path.exists(partition_path)):
os.mkdir(partition_path) os.mkdir(partition_path)
os.chmod(partition_path, 0o750) os.chmod(partition_path, 0o750)
single_ipv6_address, ipv6_range = _getPartitionIpv6(ipv6_address, i)
partition_list.append({ partition_list.append({
'address_list': [ 'address_list': [
{ {
...@@ -635,10 +654,11 @@ class StandaloneSlapOS(object): ...@@ -635,10 +654,11 @@ class StandaloneSlapOS(object):
'netmask': '255.255.255.255' 'netmask': '255.255.255.255'
}, },
{ {
'addr': ipv6_address, 'addr': single_ipv6_address,
'netmask': 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' 'netmask': 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
}, },
], ],
'ipv6_range' : ipv6_range,
'path': partition_path, 'path': partition_path,
'reference': partition_reference, 'reference': partition_reference,
'tap': { 'tap': {
......
slapos/util.py
View file @ b21e68ff
...@@ -199,6 +199,69 @@ def ipv6FromBin(ip, suffix=''): ...@@ -199,6 +199,69 @@ def ipv6FromBin(ip, suffix=''):
return socket.inet_ntop(socket.AF_INET6, return socket.inet_ntop(socket.AF_INET6,
struct.pack('>QQ', int(ip[:64], 2), int(ip[64:], 2))) struct.pack('>QQ', int(ip[:64], 2), int(ip[64:], 2)))
def getPartitionIpv6Addr(ipv6_range, partition_index):
"""
from a IPv6 range in the form
{
'addr' : addr,
'natmask' : CIDR
}
returns the IPv6 addr
addr::(partition_index+2) (address 1 is is used by re6st)
"""
addr = ipv6_range['addr']
netmask = ipv6_range['netmask']
prefix = binFromIpv6(addr)[:netmask]
return dict(addr = ipv6FromBin(prefix + bin(partition_index+2)[2:].zfill(128 - netmask)), netmask = netmask)
def getPartitionIpv6Range(ipv6_range, partition_index):
"""
from a IPv6 range in the form
{
'addr' : addr,
'natmask' : CIDR
}
returns the IPv6 range
{
'addr' : addr:(partition_index+1)
'netmask : CIDR+16
}
"""
addr = ipv6_range['addr']
netmask = ipv6_range['netmask']
prefix = binFromIpv6(addr)[:netmask]
# we generate a subnetwork for the partition
# the subnetwork has 16 bits more than our IPv6 range
# make sure we have at least 2 IPs in the subnetwork
netmask += 16
if netmask >= 128:
raise ValueError('The IPv6 range has netmask {} which is too big for generating IPv6 range for partitions.'.format(netmask))
return dict(addr = ipv6FromBin(prefix + bin(partition_index+1)[2:].zfill(16) + '0' * (128 - netmask)), netmask=netmask)
def getTapIpv6Range(ipv6_range, partition_index):
"""
from a IPv6 range in the form
{
'addr' : addr,
'natmask' : CIDR
}
returns the IPv6 range
{
'addr' : addr:(2^15 + partition_index+1)
'netmask : CIDR+16
}
"""
addr = ipv6_range['addr']
netmask = ipv6_range['netmask']
prefix = binFromIpv6(addr)[:netmask]
# we generate a subnetwork for the partition
# the subnetwork has 16 bits more than our IPv6 range
# make sure we have at least 2 IPs in the subnetwork
netmask += 16
if netmask >= 128:
raise ValueError('The IPv6 range has netmask {} which is too big for generating IPv6 range for partitions.'.format(netmask))
return dict(addr = ipv6FromBin(prefix + bin(2^15 + partition_index+1)[2:].zfill(16) + '0' * (128 - netmask)), netmask=netmask)
  • Xavier Thompson @xavier_thompson ·
    Owner

    I just noticed that 2^15 is a bitwise xor and not a power of 2. Either 2**15 or 1 << 15 should be used instead.

Please register or sign in to reply
def lenNetmaskIpv6(netmask): def lenNetmaskIpv6(netmask):
"""Convert string represented netmask to its integer prefix""" """Convert string represented netmask to its integer prefix"""
# Since version 0.10.7 of netifaces, the netmask is something like "ffff::/16", # Since version 0.10.7 of netifaces, the netmask is something like "ffff::/16",
...@@ -209,6 +272,10 @@ def lenNetmaskIpv6(netmask): ...@@ -209,6 +272,10 @@ def lenNetmaskIpv6(netmask):
except ValueError: except ValueError:
return netaddr.IPNetwork(netmask).prefixlen return netaddr.IPNetwork(netmask).prefixlen
def netmaskFromLenIPv6(netmask_len):
""" opposite of lenNetmaskIpv6"""
return ipv6FromBin('1' * netmask_len)
# Used for Python 2-3 compatibility # Used for Python 2-3 compatibility
if str is bytes: if str is bytes:
bytes2str = str2bytes = lambda s: s bytes2str = str2bytes = lambda s: s
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7