format.py 56.8 KB
Newer Older
Łukasz Nowak committed
1
# -*- coding: utf-8 -*-
Marco Mariani committed
2
# vim: set et sts=2:
Łukasz Nowak committed
3 4
##############################################################################
#
5 6
# Copyright (c) 2010, 2011, 2012 Vifib SARL and Contributors.
# All Rights Reserved.
Łukasz Nowak committed
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsibility of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# guarantees and support are strongly advised to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
##############################################################################
30

Bryton Lacquement committed
31
from six.moves import configparser
32 33
import errno
import fcntl
Łukasz Nowak committed
34
import grp
35
import json
Łukasz Nowak committed
36
import logging
37
import math
Łukasz Nowak committed
38 39 40
import netaddr
import netifaces
import os
41
import glob
Łukasz Nowak committed
42
import pwd
Łukasz Nowak committed
43
import random
44
import shutil
Łukasz Nowak committed
45
import socket
46
import struct
Łukasz Nowak committed
47 48
import subprocess
import sys
49
import threading
Łukasz Nowak committed
50
import time
51
import traceback
Marco Mariani committed
52
import zipfile
53
import platform
Bryton Lacquement committed
54 55
from six.moves.urllib.request import urlopen
import six
Marco Mariani committed
56 57

import lxml.etree
58
import xml_marshaller.xml_marshaller
Marco Mariani committed
59

Bryton Lacquement committed
60
from slapos.util import dumps, mkdir_p, ipv6FromBin, binFromIpv6, lenNetmaskIpv6
61
import slapos.slap as slap
62
from slapos import version
63
from slapos import manager as slapmanager
64

65 66 67 68

logger = logging.getLogger("slapos.format")


Marco Mariani committed
69 70 71 72
def prettify_xml(xml):
  root = lxml.etree.fromstring(xml)
  return lxml.etree.tostring(root, pretty_print=True)

Łukasz Nowak committed
73

Vincent Pelletier committed
74
class OS(object):
75 76
  """Wrap parts of the 'os' module to provide logging of performed actions."""

Vincent Pelletier committed
77 78
  _os = os

79 80 81
  def __init__(self, conf):
    self._dry_run = conf.dry_run
    self._logger = conf.logger
Vincent Pelletier committed
82 83 84 85 86 87 88 89
    add = self._addWrapper
    add('chown')
    add('chmod')
    add('makedirs')
    add('mkdir')

  def _addWrapper(self, name):
    def wrapper(*args, **kw):
90
      arg_list = [repr(x) for x in args] + [
Bryton Lacquement committed
91
          '%s=%r' % (x, y) for x, y in six.iteritems(kw)
92
      ]
93
      self._logger.debug('%s(%s)' % (name, ', '.join(arg_list)))
94 95
      if not self._dry_run:
        getattr(self._os, name)(*args, **kw)
Vincent Pelletier committed
96 97 98 99
    setattr(self, name, wrapper)

  def __getattr__(self, name):
    return getattr(self._os, name)
Łukasz Nowak committed
100

101

102 103 104
class UsageError(Exception):
  pass

105

106
class NoAddressOnInterface(Exception):
Łukasz Nowak committed
107
  """
Marco Mariani committed
108
  Exception raised if there is no address on the interface to construct IPv6
109 110 111
  address with.

  Attributes:
112
    brige: String, the name of the interface.
Łukasz Nowak committed
113 114
  """

115 116
  def __init__(self, interface):
    super(NoAddressOnInterface, self).__init__(
Marco Mariani committed
117
      'No IPv6 found on interface %s to construct IPv6 with.' % interface
118
    )
Łukasz Nowak committed
119

120

121 122 123
class AddressGenerationError(Exception):
  """
  Exception raised if the generation of an IPv6 based on the prefix obtained
124
  from the interface failed.
125 126 127 128 129 130 131 132

  Attributes:
    addr: String, the invalid address the exception is raised for.
  """
  def __init__(self, addr):
    super(AddressGenerationError, self).__init__(
      'Generated IPv6 %s seems not to be a valid IP.' % addr
    )
Łukasz Nowak committed
133

134

135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
def getPublicIPv4Address():
  test_list = [
    { "url": 'https://api.ipify.org/?format=json' , "json_key": "ip"},
    { "url": 'http://httpbin.org/ip', "json_key": "origin"},
    { "url": 'http://jsonip.com', "json_key": "ip"}]
  previous = None
  ipv4 = None
  for test in test_list:
    if ipv4 is not None:
      previous = ipv4
    try:
      ipv4 = json.load(urlopen(test["url"]))[test["json_key"]]
    except:
      ipv4 = None
    if ipv4 is not None and ipv4 == previous:
      return ipv4

Łukasz Nowak committed
152
def callAndRead(argument_list, raise_on_error=True):
Marco Mariani committed
153 154 155
  popen = subprocess.Popen(argument_list,
                           stdout=subprocess.PIPE,
                           stderr=subprocess.STDOUT)
Łukasz Nowak committed
156 157
  result = popen.communicate()[0]
  if raise_on_error and popen.returncode != 0:
158
    raise ValueError('Issue while invoking %r, result was:\n%s' % (
Marco Mariani committed
159
                     argument_list, result))
Łukasz Nowak committed
160 161
  return popen.returncode, result

162

Łukasz Nowak committed
163 164 165 166 167 168
def isGlobalScopeAddress(a):
  """Returns True if a is global scope IP v4/6 address"""
  ip = netaddr.IPAddress(a)
  return not ip.is_link_local() and not ip.is_loopback() and \
      not ip.is_reserved() and ip.is_unicast()

169

Łukasz Nowak committed
170 171 172 173 174
def netmaskToPrefixIPv4(netmask):
  """Convert string represented netmask to its integer prefix"""
  return netaddr.strategy.ipv4.netmask_to_prefix[
          netaddr.strategy.ipv4.str_to_int(netmask)]

175

Łukasz Nowak committed
176 177 178 179 180
def netmaskToPrefixIPv6(netmask):
  """Convert string represented netmask to its integer prefix"""
  return netaddr.strategy.ipv6.netmask_to_prefix[
          netaddr.strategy.ipv6.str_to_int(netmask)]

181
def getIfaceAddressIPv4(iface):
182
  """return dict containing ipv4 address netmask, network and broadcast address
183 184 185 186 187 188 189
  of interface"""
  if not iface in netifaces.interfaces():
    raise ValueError('Could not find interface called %s to use as gateway ' \
                      'for tap network' % iface)
  try:
    addresses_list = netifaces.ifaddresses(iface)[socket.AF_INET]
    if len (addresses_list) > 0:
190

191 192 193 194 195 196 197 198 199 200
      addresses = addresses_list[0].copy()
      addresses['network'] = str(netaddr.IPNetwork('%s/%s' % (addresses['addr'],
                                          addresses['netmask'])).cidr.network)
      return addresses
    else:
      return {}
  except KeyError:
    raise KeyError('Could not find IPv4 adress on interface %s.' % iface)

def getIPv4SubnetAddressRange(ip_address, mask, size):
201
  """Check if a given ipaddress can be used to create 'size'
202 203 204
  host ip address, then return list of ip address in the subnet"""
  ip = netaddr.IPNetwork('%s/%s' % (ip_address, mask))
  # Delete network and default ip_address from the list
205
  ip_list = [x for x in sorted(list(ip))
206 207 208 209 210
              if str(x) != ip_address and x.value != ip.cidr.network.value]
  if len(ip_list) < size:
    raise ValueError('Could not create %s tap interfaces from address %s.' % (
              size, ip_address))
  return ip_list
211

212
def _getDict(obj):
Łukasz Nowak committed
213
  """
214
  Serialize an object into dictionaries. List and dict will remains
Łukasz Nowak committed
215 216 217 218
  the same, basic type too. But encapsulated object will be returned as dict.
  Set, collections and other aren't handle for now.

  Args:
219
    obj: an object of any type.
Łukasz Nowak committed
220 221 222 223

  Returns:
    A dictionary if the given object wasn't a list, a list otherwise.
  """
224 225
  if isinstance(obj, list):
    return [_getDict(item) for item in obj]
Łukasz Nowak committed
226

227 228
  if isinstance(obj, dict):
    dikt = obj
Łukasz Nowak committed
229 230
  else:
    try:
231
      dikt = obj.__dict__
Łukasz Nowak committed
232
    except AttributeError:
233 234 235
      return obj

  return {
Bryton Lacquement committed
236 237
    key: _getDict(value)
    for key, value in six.iteritems(dikt)
238
    # do not attempt to serialize logger: it is both useless and recursive.
239 240
    # do not serialize attributes starting with "_", let the classes have some privacy
    if not key.startswith("_")
241
  }
Łukasz Nowak committed
242

243

244
class Computer(object):
245
  """Object representing the computer"""
Łukasz Nowak committed
246

247
  def __init__(self, reference, interface=None, addr=None, netmask=None,
248
               ipv6_interface=None, software_user='slapsoft',
249
               tap_gateway_interface=None, tap_ipv6=None,
250
               instance_root=None, software_root=None, instance_storage_home=None,
251
               partition_list=None, config=None):
Łukasz Nowak committed
252 253
    """
    Attributes:
254 255
      reference: str, the reference of the computer.
      interface: str, the name of the computer's used interface.
256 257

      :param config: dict-like, holds raw data from configuration file
Łukasz Nowak committed
258 259
    """
    self.reference = str(reference)
260
    self.interface = interface
261
    self.partition_list = partition_list or []
Łukasz Nowak committed
262 263
    self.address = addr
    self.netmask = netmask
264
    self.ipv6_interface = ipv6_interface
265
    self.software_user = software_user
266
    self.tap_gateway_interface = tap_gateway_interface
267
    self.tap_ipv6 = tap_ipv6
Łukasz Nowak committed
268

269 270 271 272 273 274 275 276
    # Used to be static attributes of the class object - didn't make sense (Marco again)
    assert instance_root is not None and software_root is not None, \
           "Computer's instance_root and software_root must not be empty!"
    self.software_root = software_root
    self.instance_root = instance_root
    self.instance_storage_home = instance_storage_home

    # The following properties are updated on update() method
277 278 279 280 281
    self.public_ipv4_address = None
    self.os_type = None
    self.python_version = None
    self.slapos_version = None

282 283
    # attributes starting with '_' are saved from serialization
    # monkey-patch use of class instead of dictionary
284 285 286 287
    if config is None:
      logger.warning("Computer needs config in constructor to allow managers.")

    self._config = config if config is None or isinstance(config, dict) else config.__dict__
288
    self._manager_list = slapmanager.from_config(self._config)
289

Łukasz Nowak committed
290
  def __getinitargs__(self):
291
    return (self.reference, self.interface)
Łukasz Nowak committed
292

293
  def getAddress(self):
Łukasz Nowak committed
294
    """
Marco Mariani committed
295
    Return a list of the interface address not attributed to any partition (which
Łukasz Nowak committed
296 297 298
    are therefore free for the computer itself).

    Returns:
299
      False if the interface isn't available, else the list of the free addresses.
Łukasz Nowak committed
300
    """
301
    if self.interface is None:
Marco Mariani committed
302
      return {'addr': self.address, 'netmask': self.netmask}
Łukasz Nowak committed
303 304 305 306 307 308

    computer_partition_address_list = []
    for partition in self.partition_list:
      for address in partition.address_list:
        if netaddr.valid_ipv6(address['addr']):
          computer_partition_address_list.append(address['addr'])
309
    # Going through addresses of the computer's interface
310
    for address_dict in self.interface.getGlobalScopeAddressList():
Łukasz Nowak committed
311 312 313 314
      # Comparing with computer's partition addresses
      if address_dict['addr'] not in computer_partition_address_list:
        return address_dict

315
    # Can't find address
Marco Mariani committed
316
    raise NoAddressOnInterface('No valid IPv6 found on %s.' % self.interface.name)
Łukasz Nowak committed
317

318
  def update(self):
319
    """Collect environmental hardware/network information."""
320 321 322 323 324
    self.public_ipv4_address = getPublicIPv4Address()
    self.slapos_version = version.version
    self.python_version = platform.python_version()
    self.os_type = platform.platform()

325
  def send(self, conf):
Łukasz Nowak committed
326 327 328 329 330
    """
    Send a marshalled dictionary of the computer object serialized via_getDict.
    """
    slap_instance = slap.slap()
    connection_dict = {}
331 332 333 334
    if conf.key_file and conf.cert_file:
      connection_dict['key_file'] = conf.key_file
      connection_dict['cert_file'] = conf.cert_file
    slap_instance.initializeConnection(conf.master_url,
Marco Mariani committed
335
                                       **connection_dict)
Łukasz Nowak committed
336
    slap_computer = slap_instance.registerComputer(self.reference)
Marco Mariani committed
337

338
    if conf.dry_run:
339
      return
340
    try:
Bryton Lacquement committed
341
      slap_computer.updateConfiguration(dumps(_getDict(self)))
342
    except slap.NotFoundError as error:
343 344 345
      raise slap.NotFoundError("%s\nERROR: This SlapOS node is not recognised by "
          "SlapOS Master and/or computer_id and certificates don't match. "
          "Please make sure computer_id of slapos.cfg looks "
346
          "like 'COMP-123' and is correct.\nError is : 404 Not Found." % error)
Łukasz Nowak committed
347

348
  def dump(self, path_to_xml, path_to_json, logger):
Łukasz Nowak committed
349 350 351 352 353
    """
    Dump the computer object to an xml file via xml_marshaller.

    Args:
      path_to_xml: String, path to the file to load.
Marco Mariani committed
354
      path_to_json: String, path to the JSON version to save.
Łukasz Nowak committed
355 356
    """

357 358 359 360
    # dump partition resources information
    for partition in self.partition_list:
      partition.dump()

Łukasz Nowak committed
361
    computer_dict = _getDict(self)
362 363 364 365 366

    if path_to_json:
      with open(path_to_json, 'wb') as fout:
        fout.write(json.dumps(computer_dict, sort_keys=True, indent=2))

Bryton Lacquement committed
367
    new_xml = dumps(computer_dict)
Marco Mariani committed
368 369 370 371
    new_pretty_xml = prettify_xml(new_xml)

    path_to_archive = path_to_xml + '.zip'

372
    if os.path.exists(path_to_archive) and os.path.exists(path_to_xml):
Marco Mariani committed
373 374 375 376 377 378
      # the archive file exists, we only backup if something has changed
      with open(path_to_xml, 'rb') as fin:
        if fin.read() == new_pretty_xml:
          # computer configuration did not change, nothing to write
          return

379
    if os.path.exists(path_to_xml):
380 381 382 383 384
      try:
        self.backup_xml(path_to_archive, path_to_xml)
      except:
        # might be a corrupted zip file. let's move it out of the way and retry.
        shutil.move(path_to_archive,
Marco Mariani committed
385
                    path_to_archive + time.strftime('_broken_%Y%m%d-%H:%M'))
386 387 388 389
        try:
          self.backup_xml(path_to_archive, path_to_xml)
        except:
          # give up trying
390
          logger.exception("Can't backup %s:", path_to_xml)
Marco Mariani committed
391

Marco Mariani committed
392 393
    with open(path_to_xml, 'wb') as fout:
      fout.write(new_pretty_xml)
Marco Mariani committed
394 395

  def backup_xml(self, path_to_archive, path_to_xml):
Marco Mariani committed
396 397 398
    """
    Stores a copy of the current xml file to an historical archive.
    """
Marco Mariani committed
399
    xml_content = open(path_to_xml).read()
Marco Mariani committed
400
    saved_filename = os.path.basename(path_to_xml) + time.strftime('.%Y%m%d-%H:%M')
Marco Mariani committed
401 402 403 404

    with zipfile.ZipFile(path_to_archive, 'a') as archive:
      archive.writestr(saved_filename, xml_content, zipfile.ZIP_DEFLATED)

Łukasz Nowak committed
405
  @classmethod
406
  def load(cls, path_to_xml, reference, ipv6_interface, tap_gateway_interface,
407
           tap_ipv6, instance_root=None, software_root=None, config=None):
Łukasz Nowak committed
408 409 410 411 412 413 414 415
    """
    Create a computer object from a valid xml file.

    Arg:
      path_to_xml: String, a path to a valid file containing
          a valid configuration.

    Return:
416
      A Computer object.
Łukasz Nowak committed
417
    """
418 419
    with open(path_to_xml, "rb") as fi:
      dumped_dict = xml_marshaller.xml_marshaller.load(fi)
Łukasz Nowak committed
420 421 422

    # Reconstructing the computer object from the xml
    computer = Computer(
423 424 425 426 427
        reference=reference,
        addr=dumped_dict['address'],
        netmask=dumped_dict['netmask'],
        ipv6_interface=ipv6_interface,
        software_user=dumped_dict.get('software_user', 'slapsoft'),
428
        tap_gateway_interface=tap_gateway_interface,
429
        tap_ipv6=tap_ipv6,
430 431
        software_root=dumped_dict.get('software_root', software_root),
        instance_root=dumped_dict.get('instance_root', instance_root),
432
        config=config,
Łukasz Nowak committed
433 434
    )

435
    partition_amount = int(config.partition_amount)
436
    for partition_index, partition_dict in enumerate(dumped_dict['partition_list']):
Łukasz Nowak committed
437 438 439 440 441 442 443 444

      if partition_dict['user']:
        user = User(partition_dict['user']['name'])
      else:
        user = User('root')

      if partition_dict['tap']:
        tap = Tap(partition_dict['tap']['name'])
445 446 447 448
        tap.ipv4_addr = partition_dict['tap'].get('ipv4_addr', '')
        tap.ipv4_netmask = partition_dict['tap'].get('ipv4_netmask', '')
        tap.ipv4_gateway = partition_dict['tap'].get('ipv4_gateway', '')
        tap.ipv4_network = partition_dict['tap'].get('ipv4_network', '')
449 450 451 452
        tap.ipv6_addr = partition_dict['tap'].get('ipv6_addr', '')
        tap.ipv6_netmask = partition_dict['tap'].get('ipv6_netmask', '')
        tap.ipv6_gateway = partition_dict['tap'].get('ipv6_gateway', '')
        tap.ipv6_network = partition_dict['tap'].get('ipv6_network', '')
Łukasz Nowak committed
453 454 455
      else:
        tap = Tap(partition_dict['reference'])

456
      if partition_dict.get('tun') is not None and partition_dict['tun'].get('ipv4_addr') is not None:
457
        tun = Tun(partition_dict['tun']['name'], partition_index, partition_amount)
458 459
        tun.ipv4_addr = partition_dict['tun']['ipv4_addr']
      else:
460
        tun = Tun("slaptun" + str(partition_index), partition_index, partition_amount)
461

Łukasz Nowak committed
462
      address_list = partition_dict['address_list']
463
      external_storage_list = partition_dict.get('external_storage_list', [])
Łukasz Nowak committed
464 465

      partition = Partition(
466 467 468 469 470
          reference=partition_dict['reference'],
          path=partition_dict['path'],
          user=user,
          address_list=address_list,
          tap=tap,
471
          tun=tun if config.create_tun else None,
472
          external_storage_list=external_storage_list,
Łukasz Nowak committed
473 474 475 476 477 478
      )

      computer.partition_list.append(partition)

    return computer

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
  def _speedHackAddAllOldIpsToInterface(self):
    """
    Speed hack:
    Blindly add all IPs from existing configuration, just to speed up actual
    computer configuration later on.
    """
    # XXX-TODO: only add an address if it doesn't already exist.
    if self.ipv6_interface:
      interface_name = self.ipv6_interface
    elif self.interface:
      interface_name = self.interface.name
    else:
      return

    for partition in self.partition_list:
      try:
        for address in partition.address_list:
          try:
            netmask = netmaskToPrefixIPv6(address['netmask'])
          except:
            continue
          callAndRead(['ip', 'addr', 'add',
                       '%s/%s' % (address['addr'], netmask),
                       'dev', interface_name])
      except ValueError:
        pass

506 507 508 509 510 511 512
  def _addUniqueLocalAddressIpv6(self, interface_name):
    """
    Create a unique local address in the interface interface_name, so that
    slapformat can build upon this.
    See https://en.wikipedia.org/wiki/Unique_local_address.
    """
    command = 'ip address add dev %s fd00::1/64' % interface_name
513
    callAndRead(command.split())
514

515 516 517 518
  @property
  def software_gid(self):
    """Return GID for self.software_user.

519
    Has to be dynamic because __init__ happens before ``format`` where we
520 521 522 523
    effectively create the user and group."""
    return pwd.getpwnam(self.software_user)[3]

  def format(self, alter_user=True, alter_network=True, create_tap=True, use_unique_local_address_block=False):
Łukasz Nowak committed
524
    """
525 526 527 528 529 530
    Setup underlaying OS so it reflects this instance (``self``).

    - setup interfaces and addresses
    - setup TAP and TUN interfaces
    - add groups and users
    - construct partitions inside slapgrid
Łukasz Nowak committed
531
    """
532
    for path in self.instance_root, self.software_root:
Łukasz Nowak committed
533
      if not os.path.exists(path):
Marco Mariani committed
534
        os.makedirs(path, 0o755)
Łukasz Nowak committed
535
      else:
Marco Mariani committed
536
        os.chmod(path, 0o755)
Łukasz Nowak committed
537

538 539
    # own self.software_root by software user
    slapsoft = User(self.software_user)
Łukasz Nowak committed
540 541 542
    slapsoft.path = self.software_root
    if alter_user:
      slapsoft.create()
Łukasz Nowak committed
543
      slapsoft_pw = pwd.getpwnam(slapsoft.name)
544
      os.chown(slapsoft.path, slapsoft_pw.pw_uid, slapsoft_pw.pw_gid)
Marco Mariani committed
545
    os.chmod(self.software_root, 0o755)
Łukasz Nowak committed
546

547 548
    # Iterate over all managers and let them `format` the computer too
    for manager in self._manager_list:
549
      manager.format(self)
550

551 552 553
    # get list of instance external storage if exist
    instance_external_list = []
    if self.instance_storage_home:
554 555 556 557 558 559 560
      # get all /XXX/dataN where N is a digit
      data_list = glob.glob(os.path.join(self.instance_storage_home, 'data*'))
      for i in range(0, len(data_list)):
        data_path = data_list.pop()
        the_digit = os.path.basename(data_path).split('data')[-1]
        if the_digit.isdigit():
          instance_external_list.append(data_path)
561

562 563 564 565 566 567
    ####################
    ### Network part ###
    ####################
    if alter_network:
      if self.address is not None:
        self.interface.addIPv6Address(self.address, self.netmask)
568

569
      if use_unique_local_address_block:
570
        self._addUniqueLocalAddressIpv6(self.ipv6_interface or self.interface.name)
571 572 573 574 575 576 577 578 579 580 581 582 583 584

      if create_tap:
        if self.tap_gateway_interface:
          gateway_addr_dict = getIfaceAddressIPv4(self.tap_gateway_interface)
          tap_address_list = getIPv4SubnetAddressRange(gateway_addr_dict['addr'],
                                gateway_addr_dict['netmask'],
                                len(self.partition_list))
          assert(len(self.partition_list) <= len(tap_address_list))
        else:
          gateway_addr_dict = {'peer': '10.0.0.1', 'netmask': '255.255.0.0',
                               'addr': '10.0.0.1', 'network': '10.0.0.0'}
          tap_address_list = getIPv4SubnetAddressRange(gateway_addr_dict['addr'],
                                 gateway_addr_dict['netmask'],
                                 len(self.partition_list))
585

586
      self._speedHackAddAllOldIpsToInterface()
587

588 589 590 591 592 593
    try:
      for partition_index, partition in enumerate(self.partition_list):
        # Reconstructing User's
        partition.path = os.path.join(self.instance_root, partition.reference)
        partition.user.setPath(partition.path)
        partition.user.additional_group_list = [slapsoft.name]
594 595
        partition.external_storage_list = ['%s/%s' % (path, partition.reference)
                                            for path in instance_external_list]
596 597 598
        if alter_user:
          partition.user.create()

599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
        # Reconstructing Tap and Tun
        if alter_network:
          if partition.user and partition.user.isAvailable():
            owner = partition.user
          else:
            owner = User('root')

          if create_tap:
            partition.tap.createWithOwner(owner)

            # add addresses and create route for this tap
            if not partition.tap.ipv4_addr:
              # define new ipv4 address for this tap
              next_ipv4_addr = '%s' % tap_address_list.pop(0)
              partition.tap.ipv4_addr = next_ipv4_addr
              partition.tap.ipv4_netmask = gateway_addr_dict['netmask']
              partition.tap.ipv4_gateway = gateway_addr_dict['addr']
              partition.tap.ipv4_network = gateway_addr_dict['network']

618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
            if self.tap_ipv6:
              if not partition.tap.ipv6_addr:
                # create a new IPv6 randomly for the tap
                ipv6_dict = self.interface.addIPv6Address(tap=partition.tap)
                partition.tap.ipv6_addr = ipv6_dict['addr']
                partition.tap.ipv6_netmask = ipv6_dict['netmask']
              else:
                # make sure the tap has its IPv6
                self.interface.addIPv6Address(
                        addr=partition.tap.ipv6_addr,
                        netmask=partition.tap.ipv6_netmask,
                        tap=partition.tap)

              # construct ipv6_network (16 bit more than the computer network)
              netmask_len = lenNetmaskIpv6(self.interface.getGlobalScopeAddressList()[0]['netmask']) + 16
              prefix = binFromIpv6(partition.tap.ipv6_addr)[:netmask_len]
              network_addr = ipv6FromBin(prefix)
635 636
              partition.tap.ipv6_gateway = "{}1".format(network_addr) # address network::1 will be inside the VM
              partition.tap.ipv6_gateway = ipv6FromBin(binFromIpv6(partition.tap.ipv6_gateway)) # correctly format the IPv6
637
              partition.tap.ipv6_network = "{}/{}".format(network_addr, netmask_len)
638
            else:
639 640 641 642 643 644
              partition.tap.ipv6_addr = ''
              partition.tap.ipv6_netmask = ''
              partition.tap.ipv6_gateway = ''
              partition.tap.ipv6_network = ''

            # create IPv4 and IPv6 routes
645 646 647 648 649 650
            partition.tap.createRoutes()

          if partition.tun is not None:
            # create TUN interface per partition as well
            partition.tun.createWithOwner(owner)
            partition.tun.createRoutes()
651

652 653
        # Reconstructing partition's directory
        partition.createPath(alter_user)
654
        partition.createExternalPath(alter_user)
655 656 657 658

        # Reconstructing partition's address
        # There should be two addresses on each Computer Partition:
        #  * local IPv4, took from slapformat:ipv4_local_network
659
        #  * global IPv6
Marco Mariani committed
660
        if not partition.address_list:
661
          # regenerate
662
          partition.address_list.append(self.interface.addIPv4LocalAddress())
663
          partition.address_list.append(self.interface.addIPv6Address())
664 665 666 667 668
        elif alter_network:
          # regenerate list of addresses
          old_partition_address_list = partition.address_list
          partition.address_list = []
          if len(old_partition_address_list) != 2:
669 670 671
            raise ValueError(
              'There should be exactly 2 stored addresses. Got: %r' %
              (old_partition_address_list,))
Marco Mariani committed
672 673
          if not any(netaddr.valid_ipv6(q['addr'])
                     for q in old_partition_address_list):
674
            raise ValueError('Not valid ipv6 addresses loaded')
Marco Mariani committed
675 676
          if not any(netaddr.valid_ipv4(q['addr'])
                     for q in old_partition_address_list):
677
            raise ValueError('Not valid ipv6 addresses loaded')
Marco Mariani committed
678

679 680
          for address in old_partition_address_list:
            if netaddr.valid_ipv6(address['addr']):
681
              partition.address_list.append(self.interface.addIPv6Address(
Vincent Pelletier committed
682 683
                address['addr'],
                address['netmask']))
684
            elif netaddr.valid_ipv4(address['addr']):
685
              partition.address_list.append(self.interface.addIPv4LocalAddress(
Vincent Pelletier committed
686
                address['addr']))
687 688 689
            else:
              raise ValueError('Address %r is incorrect' % address['addr'])
    finally:
690 691 692
      for manager in self._manager_list:
        manager.formatTearDown(self)

693

694
class Partition(object):
695 696 697
  """Represent a computer partition."""

  resource_file = ".slapos-resource"
Łukasz Nowak committed
698

699
  def __init__(self, reference, path, user, address_list,
700
               tap, external_storage_list=[], tun=None):
Łukasz Nowak committed
701 702 703 704 705 706
    """
    Attributes:
      reference: String, the name of the partition.
      path: String, the path to the partition folder.
      user: User, the user linked to this partition.
      address_list: List of associated IP addresses.
707
      tap: Tap, the tap interface linked to this partition e.g. used as a gateway for kvm
708
      tun: Tun interface used for special apps simulating ethernet connections
709
      external_storage_list: Base path list of folder to format for data storage
Łukasz Nowak committed
710 711 712 713 714 715 716
    """

    self.reference = str(reference)
    self.path = str(path)
    self.user = user
    self.address_list = address_list or []
    self.tap = tap
717
    self.tun = tun
718
    self.external_storage_list = []
Łukasz Nowak committed
719 720

  def __getinitargs__(self):
721
    return (self.reference, self.path, self.user, self.address_list, self.tap, self.tun)
Łukasz Nowak committed
722 723 724

  def createPath(self, alter_user=True):
    """
Vincent Pelletier committed
725 726
    Create the directory of the partition, assign to the partition user and
    give it the 750 permission. In case if path exists just modifies it.
Łukasz Nowak committed
727 728
    """

729
    self.path = os.path.abspath(self.path)
Łukasz Nowak committed
730
    owner = self.user if self.user else User('root')
731
    if not os.path.exists(self.path):
Marco Mariani committed
732
      os.mkdir(self.path, 0o750)
Łukasz Nowak committed
733
    if alter_user:
Łukasz Nowak committed
734
      owner_pw = pwd.getpwnam(owner.name)
735
      os.chown(self.path, owner_pw.pw_uid, owner_pw.pw_gid)
736
    os.chmod(self.path, 0o750)
Łukasz Nowak committed
737

738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
  def createExternalPath(self, alter_user=True):
    """
    Create and external directory of the partition, assign to the partition user
    and give it the 750 permission. In case if path exists just modifies it.
    """

    for path in self.external_storage_list:
      storage_path = os.path.abspath(path)
      owner = self.user if self.user else User('root')
      if not os.path.exists(storage_path):
        os.mkdir(storage_path, 0o750)
      if alter_user:
        owner_pw = pwd.getpwnam(owner.name)
        os.chown(storage_path, owner_pw.pw_uid, owner_pw.pw_gid)
      os.chmod(storage_path, 0o750)
753

754 755 756 757
  def dump(self):
    """Dump available resources into ~partition_home/.slapos-resource."""
    file_path = os.path.join(self.path, self.resource_file)
    data = _getDict(self)
758 759 760 761 762 763 764
    content = json.dumps(data, sort_keys=True, indent=4)
    if os.path.exists(file_path):
      with open(file_path, "r") as f:
        if f.read() == content:
          # dumped resources didn't change
          return

765
    with open(file_path, "wb") as fo:
766
      fo.write(content)
767
    owner_pw = pwd.getpwnam(self.user.name)
768
    os.chmod(file_path, 0o644)
769 770
    logger.info("Partition resources saved to {}".format(
      self.reference, file_path))
771 772


773
class User(object):
Marco Mariani committed
774 775
  """User: represent and manipulate a user on the system."""

776
  path = None
Łukasz Nowak committed
777 778 779 780 781 782 783

  def __init__(self, user_name, additional_group_list=None):
    """
    Attributes:
        user_name: string, the name of the user, who will have is home in
    """
    self.name = str(user_name)
784
    self.shell = '/bin/sh'
Łukasz Nowak committed
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
    self.additional_group_list = additional_group_list

  def __getinitargs__(self):
    return (self.name,)

  def setPath(self, path):
    self.path = path

  def create(self):
    """
    Create a user on the system who will be named after the self.name with its
    own group and directory.

    Returns:
        True: if the user creation went right
    """
    # XXX: This method shall be no-op in case if all is correctly setup
    #      This method shall check if all is correctly done
    #      This method shall not reset groups, just add them
Jondy Zhao committed
804
    grpname = 'grp_' + self.name if sys.platform == 'cygwin' else self.name
Łukasz Nowak committed
805
    try:
Jondy Zhao committed
806
      grp.getgrnam(grpname)
Łukasz Nowak committed
807
    except KeyError:
Jondy Zhao committed
808
      callAndRead(['groupadd', grpname])
Łukasz Nowak committed
809

810
    user_parameter_list = ['-d', self.path, '-g', self.name, '-s', self.shell]
Łukasz Nowak committed
811 812 813 814
    if self.additional_group_list is not None:
      user_parameter_list.extend(['-G', ','.join(self.additional_group_list)])
    user_parameter_list.append(self.name)
    try:
Łukasz Nowak committed
815
      pwd.getpwnam(self.name)
Łukasz Nowak committed
816
    except KeyError:
817
      user_parameter_list.append('-r')
Łukasz Nowak committed
818 819
      callAndRead(['useradd'] + user_parameter_list)
    else:
820 821
      # if the user is already created and used we should not fail
      callAndRead(['usermod'] + user_parameter_list, raise_on_error=False)
822 823
    # lock the password of user
    callAndRead(['passwd', '-l', self.name])
Łukasz Nowak committed
824 825 826 827 828 829 830 831 832 833 834 835 836

    return True

  def isAvailable(self):
    """
    Determine the availability of a user on the system

    Return:
        True: if available
        False: otherwise
    """

    try:
Łukasz Nowak committed
837
      pwd.getpwnam(self.name)
Łukasz Nowak committed
838 839 840 841
      return True
    except KeyError:
      return False

842

843
class Tap(object):
Łukasz Nowak committed
844
  "Tap represent a tap interface on the system"
845 846 847
  IFF_TAP = 0x0002
  TUNSETIFF = 0x400454ca
  KEEP_TAP_ATTACHED_EVENT = threading.Event()
848
  MODE = "tap"
Łukasz Nowak committed
849 850 851 852 853

  def __init__(self, tap_name):
    """
    Attributes:
        tap_name: String, the name of the tap interface.
854 855
        ipv4_address: String, local ipv4 to route to this tap
        ipv4_network: String, netmask to use when configure route for this tap
856
        ipv4_gateway: String, ipv4 of gateway to be used to reach local network
Łukasz Nowak committed
857 858 859
    """

    self.name = str(tap_name)
860 861 862 863
    self.ipv4_addr = ""
    self.ipv4_netmask = ""
    self.ipv4_gateway = ""
    self.ipv4_network = ""
864 865 866 867 868
    self.ipv6_addr = ""
    self.ipv6_netmask = ""
    self.ipv6_gateway = ""
    self.ipv6_network = ""

Łukasz Nowak committed
869 870 871 872

  def __getinitargs__(self):
    return (self.name,)

873
  def createWithOwner(self, owner):
Łukasz Nowak committed
874
    """
875
    Create a tap interface on the system if it doesn't exist yet.
Łukasz Nowak committed
876 877 878 879
    """
    check_file = '/sys/devices/virtual/net/%s/owner' % self.name
    owner_id = None
    if os.path.exists(check_file):
880 881
      with open(check_file) as fx:
        owner_id = fx.read().strip()
Łukasz Nowak committed
882
      try:
883 884
        owner_id = int(owner_id)
      except ValueError:
885 886 887 888 889 890 891 892 893 894 895
        owner_id = pwd.getpwnam(owner_id).pw_uid
      #
      if owner_id != pwd.getpwnam(owner.name).pw_uid:
        logger.warning("Wrong owner of TUN/TAP interface {}! Not touching it."
                       "Expected {:d} got {:d}".format(
          self.name, pwd.getpwnam(owner.name).pw_uid, owner_id))
      # if the interface already exists - don't do anything
      return

    callAndRead(['ip', 'tuntap', 'add', 'dev', self.name, 'mode',
                 self.MODE, 'user', owner.name])
Łukasz Nowak committed
896 897
    callAndRead(['ip', 'link', 'set', self.name, 'up'])

898
  def createRoutes(self):
899
    """
900
    Configure ipv4 and ipv6 routes
901
    """
902 903
    if self.ipv4_addr:
      # Check if this route exits
904 905
      code, result = callAndRead(['ip', 'route', 'show', self.ipv4_addr],
                                 raise_on_error=False)
906 907
      if code != 0 or self.ipv4_addr not in result or self.name not in result:
        callAndRead(['ip', 'route', 'add', self.ipv4_addr, 'dev', self.name])
908 909 910
    else:
      raise ValueError("%s should not be empty. No ipv4 address assigned to %s" %
                         (self.ipv4_addr, self.name))
911

912 913
    if self.ipv6_network:
      # Check if this route exits
914 915 916 917 918
      code, result = callAndRead(['ip', '-6', 'route', 'show', self.ipv6_gateway],
                                 raise_on_error=False)
      if code != 0 or self.name not in result:
        callAndRead(['ip', '-6', 'route', 'add', self.ipv6_gateway, 'dev', self.name])

919 920
      code, result = callAndRead(['ip', '-6', 'route', 'show', self.ipv6_network],
                                 raise_on_error=False)
921 922 923 924 925
      if code != 0 or 'via {}'.format(self.ipv6_gateway) not in result or 'dev {}'.format(self.name) not in result:
        if 'dev {}'.format(self.name) in result:
          callAndRead(['ip', '-6', 'route', 'del', self.ipv6_network, 'dev', self.name]) # remove old route without the "via" option
        callAndRead(['ip', '-6', 'route', 'add', self.ipv6_network, 'dev', self.name, 'via', self.ipv6_gateway])

926

927 928 929

class Tun(Tap):
  """Represent TUN interface which might be many per user."""
930

931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
  MODE = "tun"
  BASE_MASK = 12
  BASE_NETWORK = "172.16.0.0"

  def __init__(self, name, sequence=None, partitions=None):
    """Create TUN interface with subnet according to the optional ``sequence`` number.

    :param name: name which will appear in ``ip list`` afterwards
    :param sequence: {int} position of this TUN among all ``partitions``
    """
    super(Tun, self).__init__(name)
    if sequence is not None:
      assert 0 <= sequence < partitions, "0 <= {} < {}".format(sequence, partitions)
      # create base IPNetwork
      ip_network = netaddr.IPNetwork(Tun.BASE_NETWORK + "/" + str(Tun.BASE_MASK))
      # compute shift in BITS to separate ``partitions`` networks into subset
      # example: for 30 partitions we need log2(30) = 8 BITS
      mask_shift = int(math.ceil(math.log(int(partitions), 2.0)))
      # IPNetwork.subnet returns iterator over all possible subnets of given mask
      ip_subnets = list(ip_network.subnet(Tun.BASE_MASK + mask_shift))
      subnet = ip_subnets[sequence]
      # For serialization purposes, convert directly to ``str``
      self.ipv4_network = str(subnet)
      self.ipv4_addr = str(subnet.ip)
      self.ipv4_netmask = str(subnet.netmask)

  def createRoutes(self):
    """Extend for physical addition of network address because TAP let this on external class."""
    if self.ipv4_network:
      # add an address
      code, _ = callAndRead(['ip', 'addr', 'add', self.ipv4_network, 'dev', self.name],
                            raise_on_error=False)
      if code == 0:
        # address added to the interface - wait
        time.sleep(1)
    else:
      raise RuntimeError("Cannot setup address on interface {}. "
                         "Address is missing.".format(self.name))
    # create routes
    super(Tun, self).createRoutes()
    # add iptables rule to accept connections from this interface
    chain_rule = ['INPUT', '-i', self.name, '-j', 'ACCEPT']
    code, _ = callAndRead(['iptables', '-C'] + chain_rule, raise_on_error=False)
    if code == 0:
      # 0 means the rule does not exits so we are free to insert it
      callAndRead(['iptables', '-I'] + chain_rule)


979
class Interface(object):
Marco Mariani committed
980
  """Represent a network interface on the system"""
Łukasz Nowak committed
981

982
  def __init__(self, logger, name, ipv4_local_network, ipv6_interface=None):
Łukasz Nowak committed
983 984
    """
    Attributes:
985
        name: String, the name of the interface
Łukasz Nowak committed
986 987
    """

988
    self._logger = logger
Łukasz Nowak committed
989 990
    self.name = str(name)
    self.ipv4_local_network = ipv4_local_network
991
    self.ipv6_interface = ipv6_interface
Łukasz Nowak committed
992

993
  # XXX no __getinitargs__, as instances of this class are never deserialized.
Łukasz Nowak committed
994 995

  def getIPv4LocalAddressList(self):
Vincent Pelletier committed
996 997 998 999
    """
    Returns currently configured local IPv4 addresses which are in
    ipv4_local_network
    """
Łukasz Nowak committed
1000 1001
    if not socket.AF_INET in netifaces.ifaddresses(self.name):
      return []
Marco Mariani committed
1002 1003 1004 1005 1006 1007 1008 1009 1010
    return [
            {
                'addr': q['addr'],
                'netmask': q['netmask']
                }
            for q in netifaces.ifaddresses(self.name)[socket.AF_INET]
            if netaddr.IPAddress(q['addr'], 4) in netaddr.glob_to_iprange(
                netaddr.cidr_to_glob(self.ipv4_local_network))
            ]
Łukasz Nowak committed
1011

1012
  def getGlobalScopeAddressList(self, tap=None):
Łukasz Nowak committed
1013
    """Returns currently configured global scope IPv6 addresses"""
1014
    interface_name = self.ipv6_interface or self.name
1015
    try:
Marco Mariani committed
1016
      address_list = [
1017 1018 1019 1020
          q
          for q in netifaces.ifaddresses(interface_name)[socket.AF_INET6]
          if isGlobalScopeAddress(q['addr'].split('%')[0])
      ]
1021
    except KeyError:
1022
      raise ValueError("%s must have at least one IPv6 address assigned" %
1023
                         interface_name)
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034

    if tap:
      try:
        address_list += [
          q
          for q in netifaces.ifaddresses(tap.name)[socket.AF_INET6]
          if isGlobalScopeAddress(q['addr'].split('%')[0])
      ]
      except KeyError:
        pass

Jondy Zhao committed
1035 1036
    if sys.platform == 'cygwin':
      for q in address_list:
1037
        q.setdefault('netmask', 'FFFF:FFFF:FFFF:FFFF::')
Łukasz Nowak committed
1038 1039 1040 1041 1042 1043 1044 1045 1046
    # XXX: Missing implementation of Unique Local IPv6 Unicast Addresses as
    # defined in http://www.rfc-editor.org/rfc/rfc4193.txt
    # XXX: XXX: XXX: IT IS DISALLOWED TO IMPLEMENT link-local addresses as
    # Linux and BSD are possibly wrongly implementing it -- it is "too local"
    # it is impossible to listen or access it on same node
    # XXX: IT IS DISALLOWED to implement ad hoc solution like inventing node
    # local addresses or anything which does not exists in RFC!
    return address_list

1047
  def _addSystemAddress(self, address, netmask, ipv6=True, tap=None):
1048
    """Adds system address to interface
1049

Łukasz Nowak committed
1050 1051 1052 1053
    Returns True if address was added successfully.

    Returns False if there was issue.
    """
1054

Łukasz Nowak committed
1055 1056 1057
    if ipv6:
      address_string = '%s/%s' % (address, netmaskToPrefixIPv6(netmask))
      af = socket.AF_INET6
1058
      interface_name = self.ipv6_interface or self.name
Łukasz Nowak committed
1059 1060 1061
    else:
      af = socket.AF_INET
      address_string = '%s/%s' % (address, netmaskToPrefixIPv4(netmask))
1062
      interface_name = self.name
Łukasz Nowak committed
1063

1064 1065 1066

    if tap:
      interface_name = tap.name
Łukasz Nowak committed
1067 1068
    # check if address is already took by any other interface
    for interface in netifaces.interfaces():
1069
      if interface != interface_name:
Łukasz Nowak committed
1070 1071
        address_dict = netifaces.ifaddresses(interface)
        if af in address_dict:
1072
          if address in [q['addr'].split('%')[0] for q in address_dict[af]]:
1073 1074
            self._logger.warning('Cannot add address %s to %s as it already exists on interface %s.' % \
                (address, interface_name, interface))
Łukasz Nowak committed
1075 1076
            return False

Vincent Pelletier committed
1077 1078
    if not af in netifaces.ifaddresses(interface_name) \
        or not address in [q['addr'].split('%')[0]
Marco Mariani committed
1079 1080
                           for q in netifaces.ifaddresses(interface_name)[af]
                           ]:
Łukasz Nowak committed
1081
      # add an address
1082
      callAndRead(['ip', 'addr', 'add', address_string, 'dev', interface_name])
1083 1084 1085 1086 1087

      # Fake success for local ipv4
      if not ipv6:
        return True

Łukasz Nowak committed
1088 1089
      # wait few moments
      time.sleep(2)
1090 1091 1092 1093 1094 1095

    # Fake success for local ipv4
    if not ipv6:
      return True

    # check existence on interface for ipv6
1096
    _, result = callAndRead(['ip', '-6', 'addr', 'list', interface_name])
Łukasz Nowak committed
1097 1098
    for l in result.split('\n'):
      if address in l:
1099
        if 'tentative' in l and not tap:
Łukasz Nowak committed
1100
          # duplicate, remove
Marco Mariani committed
1101
          callAndRead(['ip', 'addr', 'del', address_string, 'dev', interface_name])
Łukasz Nowak committed
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
          return False
        # found and clean
        return True
    # even when added not found, this is bad...
    return False

  def _generateRandomIPv4Address(self, netmask):
    # no addresses found, generate new one
    # Try 10 times to add address, raise in case if not possible
    try_num = 10
    while try_num > 0:
      addr = random.choice([q for q in netaddr.glob_to_iprange(
        netaddr.cidr_to_glob(self.ipv4_local_network))]).format()
1115 1116
      if (dict(addr=addr, netmask=netmask) not in
            self.getIPv4LocalAddressList()):
Łukasz Nowak committed
1117 1118 1119 1120 1121 1122 1123 1124 1125
        # Checking the validity of the IPv6 address
        if self._addSystemAddress(addr, netmask, False):
          return dict(addr=addr, netmask=netmask)
        try_num -= 1

    raise AddressGenerationError(addr)

  def addIPv4LocalAddress(self, addr=None):
    """Adds local IPv4 address in ipv4_local_network"""
1126
    netmask = str(netaddr.IPNetwork(self.ipv4_local_network).netmask) if sys.platform == 'cygwin' \
1127
             else '255.255.255.255'
Łukasz Nowak committed
1128 1129 1130 1131
    local_address_list = self.getIPv4LocalAddressList()
    if addr is None:
      return self._generateRandomIPv4Address(netmask)
    elif dict(addr=addr, netmask=netmask) not in local_address_list:
1132 1133 1134
      if self._addSystemAddress(addr, netmask, False):
        return dict(addr=addr, netmask=netmask)
      else:
1135
        self._logger.warning('Impossible to add old local IPv4 %s. Generating '
1136
            'new IPv4 address.' % addr)
1137
        return self._generateRandomIPv4Address(netmask)
Łukasz Nowak committed
1138 1139 1140 1141
    else:
      # confirmed to be configured
      return dict(addr=addr, netmask=netmask)

1142
  def addIPv6Address(self, addr=None, netmask=None, tap=None):
Łukasz Nowak committed
1143
    """
1144
    Adds IPv6 address to interface.
Łukasz Nowak committed
1145

1146
    If addr is specified and exists already on interface, do nothing.
Łukasz Nowak committed
1147

1148 1149
    If addr is specified and does not exist on interface, try to add given
    address. If it is not possible (ex. because network changed), calculate new
Vincent Pelletier committed
1150
    address.
Łukasz Nowak committed
1151 1152

    Args:
1153
      addr: Wished address to be added to interface.
Łukasz Nowak committed
1154
      netmask: Wished netmask to be used.
1155
      tap: tap interface
Łukasz Nowak committed
1156 1157

    Returns:
1158
      dict(addr=address, netmask=netmask).
Łukasz Nowak committed
1159 1160 1161

    Raises:
      AddressGenerationError: Couldn't construct valid address with existing
1162 1163
          one's on the interface.
      NoAddressOnInterface: There's no address on the interface to construct
Łukasz Nowak committed
1164 1165
          an address with.
    """
1166 1167
    interface_name = self.ipv6_interface or self.name

1168 1169
    # Getting one address of the interface as base of the next addresses
    interface_addr_list = self.getGlobalScopeAddressList()
Łukasz Nowak committed
1170
    # No address found
1171 1172 1173
    if len(interface_addr_list) == 0:
      raise NoAddressOnInterface(interface_name)
    address_dict = interface_addr_list[0]
Łukasz Nowak committed
1174 1175

    if addr is not None:
1176 1177 1178
      dict_addr_netmask = dict(addr=addr, netmask<