ifupdown/ifupdownmain.py

   1 #!/usr/bin/python
   2 #
   3 # Copyright 2014 Cumulus Networks, Inc. All rights reserved.
   4 # Author: Roopa Prabhu, roopa@cumulusnetworks.com
   5 #
   6 # ifupdownMain --
   7 #    ifupdown main module
   8 #
   9
  10 import os
  11 import re
  12 import imp
  13 import pprint
  14 import logging
  15 import sys, traceback
  16 import copy
  17 import json
  18 from statemanager import *
  19 from networkinterfaces import *
  20 from iface import *
  21 from scheduler import *
  22 from collections import deque
  23 from collections import OrderedDict
  24 from graph import *
  25 from sets import Set
  26
  27 """
  28 .. module:: ifupdownmain
  29 :synopsis: main module for ifupdown package
  30
  31 .. moduleauthor:: Roopa Prabhu <roopa@cumulusnetworks.com>
  32
  33 """
  34
  35 _tickmark = u'\u2713'
  36 _crossmark = u'\u2717'
  37 _success_sym = '(%s)' %_tickmark
  38 _error_sym = '(%s)' %_crossmark
  39
  40 class ifupdownFlags():
  41     FORCE = False
  42     DRYRUN = False
  43     NOWAIT = False
  44     PERFMODE = False
  45     CACHE = False
  46
  47     # Flags
  48     CACHE_FLAGS = 0x0
  49
  50 class ifupdownMain(ifupdownBase):
  51     """ ifupdown2 main class """
  52
  53     # Flags
  54     WITH_DEPENDS = False
  55     ALL = False
  56     IFACE_CLASS = False
  57     COMPAT_EXEC_SCRIPTS = False
  58     STATEMANAGER_ENABLE = True
  59     STATEMANAGER_UPDATE = True
  60     ADDONS_ENABLE = False
  61
  62     # priv flags to mark iface objects
  63     BUILTIN = 0x0001
  64     NOCONFIG = 0x0010
  65
  66     scripts_dir='/etc/network'
  67     addon_modules_dir='/usr/share/ifupdownaddons'
  68     addon_modules_configfile='/var/lib/ifupdownaddons/addons.conf'
  69
  70     # iface dictionary in the below format:
  71     # { '<ifacename>' : [<ifaceobject1>, <ifaceobject2> ..] }
  72     # eg:
  73     # { 'swp1' : [<iface swp1>, <iface swp2> ..] }
  74     #
  75     # Each ifaceobject corresponds to a configuration block for
  76     # that interface
  77     # The value in the dictionary is a list because the network
  78     # interface configuration file supports more than one iface section
  79     # in the interfaces file
  80     ifaceobjdict = OrderedDict()
  81
  82     # iface dictionary representing the curr running state of an iface
  83     # in the below format:
  84     # {'<ifacename>' : <ifaceobject>}
  85     ifaceobjcurrdict = OrderedDict()
  86
  87     # Dictionary representing operation and modules
  88     # for every operation
  89     module_ops = OrderedDict([('pre-up', []),
  90                               ('up' , []),
  91                               ('post-up' , []),
  92                               ('query-checkcurr', []),
  93                               ('query-running', []),
  94                               ('query-dependency', []),
  95                               ('query', []),
  96                               ('query-raw', []),
  97                               ('pre-down', []),
  98                               ('down' , []),
  99                               ('post-down' , [])])
 100
 101     # For old style /etc/network/ bash scripts
 102     script_ops = OrderedDict([('pre-up', []),
 103                                     ('up' , []),
 104                                     ('post-up' , []),
 105                                     ('pre-down', []),
 106                                     ('down' , []),
 107                                     ('post-down' , [])])
 108
 109     # Handlers for ops that ifupdown2 owns
 110     def run_up(self, ifaceobj):
 111         # Skip link sets on ifaceobjs of type 'vlan' (used for l2 attrs).
 112         # there is no real interface behind it
 113         if ifaceobj.type == ifaceType.BRIDGE_VLAN:
 114             return
 115         if (ifaceobj.addr_method and
 116             ifaceobj.addr_method == 'manual'):
 117             return
 118         if self._delay_admin_state:
 119             self._delay_admin_state_iface_queue.append(ifaceobj.name)
 120             return
 121         # If this object is a link slave, ie its link is controlled
 122         # by its link master interface, then dont set the link state.
 123         # But do allow user to change state of the link if the interface
 124         # is already with its link master (hence the master check).
 125         if ifaceobj.link_type == ifaceLinkType.LINK_SLAVE:
 126             return
 127         if not self.link_exists(ifaceobj.name):
 128            return
 129         self.link_up(ifaceobj.name)
 130
 131     def run_down(self, ifaceobj):
 132         # Skip link sets on ifaceobjs of type 'vlan' (used for l2 attrs)
 133         # there is no real interface behind it
 134         if ifaceobj.type == ifaceType.BRIDGE_VLAN:
 135             return
 136         if (ifaceobj.addr_method and
 137             ifaceobj.addr_method == 'manual'):
 138             return
 139         if self._delay_admin_state:
 140             self._delay_admin_state_iface_queue.append(ifaceobj.name)
 141             return
 142         # If this object is a link slave, ie its link is controlled
 143         # by its link master interface, then dont set the link state.
 144         # But do allow user to change state of the link if the interface
 145         # is already with its link master (hence the master check).
 146         if ifaceobj.link_type == ifaceLinkType.LINK_SLAVE:
 147            return
 148         if not self.link_exists(ifaceobj.name):
 149            return
 150         self.link_down(ifaceobj.name)
 151
 152     # ifupdown object interface operation handlers
 153     ops_handlers = OrderedDict([('up', run_up),
 154                                 ('down', run_down)])
 155
 156     def run_sched_ifaceobj_posthook(self, ifaceobj, op):
 157         if ((ifaceobj.priv_flags & self.BUILTIN) or
 158             (ifaceobj.priv_flags & self.NOCONFIG)):
 159             return
 160         if self.STATEMANAGER_UPDATE:
 161             self.statemanager.ifaceobj_sync(ifaceobj, op)
 162
 163     # ifupdown object interface scheduler pre and posthooks
 164     sched_hooks = {'posthook' : run_sched_ifaceobj_posthook}
 165
 166     def __init__(self, config={},
 167                  force=False, dryrun=False, nowait=False,
 168                  perfmode=False, withdepends=False, njobs=1,
 169                  cache=False, addons_enable=True, statemanager_enable=True,
 170                  interfacesfile='/etc/network/interfaces',
 171                  interfacesfileiobuf=None,
 172                  interfacesfileformat='native'):
 173         """This member function initializes the ifupdownmain object.
 174
 175         Kwargs:
 176             config (dict):  config dict from /etc/network/ifupdown2/ifupdown2.conf
 177             force (bool): force interface configuration
 178             dryrun (bool): dryrun interface configuration
 179             withdepends (bool): apply interface configuration on all depends
 180             interfacesfile (str): interfaces file. default is /etc/network/interfaces
 181             interfacesfileformat (str): default is 'native'. Other choices are 'json'
 182
 183         Raises:
 184             AttributeError, KeyError """
 185
 186         self.logger = logging.getLogger('ifupdown')
 187         self.FORCE = force
 188         self.DRYRUN = dryrun
 189         self.NOWAIT = nowait
 190         self.PERFMODE = perfmode
 191         self.WITH_DEPENDS = withdepends
 192         self.STATEMANAGER_ENABLE = statemanager_enable
 193         self.CACHE = cache
 194         self.interfacesfile = interfacesfile
 195         self.interfacesfileiobuf = interfacesfileiobuf
 196         self.interfacesfileformat = interfacesfileformat
 197         self.config = config
 198         self.logger.debug(self.config)
 199
 200         self.type = ifaceType.UNKNOWN
 201
 202         # Can be used to provide hints for caching
 203         self.CACHE_FLAGS = 0x0
 204         self._DELETE_DEPENDENT_IFACES_WITH_NOCONFIG = False
 205         self.ADDONS_ENABLE = addons_enable
 206
 207         # Copy flags into ifupdownFlags
 208         # XXX: before we transition fully to ifupdownFlags
 209         ifupdownFlags.FORCE = force
 210         ifupdownFlags.DRYRUN = dryrun
 211         ifupdownFlags.NOWAIT = nowait
 212         ifupdownFlags.PERFMODE = perfmode
 213         ifupdownFlags.CACHE = cache
 214
 215         self.ifaces = OrderedDict()
 216         self.njobs = njobs
 217         self.pp = pprint.PrettyPrinter(indent=4)
 218         self.modules = OrderedDict({})
 219         self.module_attrs = {}
 220
 221         self.load_addon_modules(self.addon_modules_dir)
 222         if self.COMPAT_EXEC_SCRIPTS:
 223             self.load_scripts(self.scripts_dir)
 224         self.dependency_graph = OrderedDict({})
 225
 226         self._cache_no_repeats = {}
 227
 228         if self.STATEMANAGER_ENABLE:
 229             try:
 230                 self.statemanager = stateManager()
 231                 self.statemanager.read_saved_state()
 232             except Exception, e:
 233                 # XXX Maybe we should continue by ignoring old state
 234                 self.logger.warning('error reading state (%s)' %str(e))
 235                 raise
 236         else:
 237             self.STATEMANAGER_UPDATE = False
 238         self._delay_admin_state = True if self.config.get(
 239                             'delay_admin_state_change', '0') == '1' else False
 240         self._delay_admin_state_iface_queue = []
 241         if self._delay_admin_state:
 242             self.logger.info('\'delay_admin_state_change\' is set. admin ' +
 243                              'state changes will be delayed till the end.')
 244
 245         self._link_master_slave = True if self.config.get(
 246                       'link_master_slave', '0') == '1' else False
 247         if self._link_master_slave:
 248             self.logger.info('\'link_master_slave\' is set. slave admin ' +
 249                              'state changes will be delayed till the ' +
 250                              'masters admin state change.')
 251
 252     def link_master_slave_ignore_error(self, errorstr):
 253         # If link master slave flag is set,
 254         # there may be cases where the lowerdev may not be
 255         # up resulting in 'Network is down' error
 256         # This can happen if the lowerdev is a LINK_SLAVE
 257         # of another interface which is not up yet
 258         # example of such a case:
 259         #   bringing up a vlan on a bond interface and the bond
 260         #   is a LINK_SLAVE of a bridge (in other words the bond is
 261         #   part of a bridge) which is not up yet
 262         if self._link_master_slave:
 263            if 'Network is down':
 264               return True
 265         return False
 266
 267     def get_ifaceobjs(self, ifacename):
 268         return self.ifaceobjdict.get(ifacename)
 269
 270     def get_ifaceobjs_saved(self, ifacename):
 271         """ Return ifaceobjects from statemanager """
 272         if self.STATEMANAGER_ENABLE:
 273            return self.statemanager.get_ifaceobjs(ifacename)
 274         else:
 275            None
 276
 277     def get_ifaceobj_first(self, ifacename):
 278         ifaceobjs = self.get_ifaceobjs(ifacename)
 279         if ifaceobjs:
 280             return ifaceobjs[0]
 281         return None
 282
 283     def get_ifacenames(self):
 284         return self.ifaceobjdict.keys()
 285
 286     def get_iface_obj_last(self, ifacename):
 287         return self.ifaceobjdict.get(ifacename)[-1]
 288
 289
 290     def must_follow_upperifaces(self, ifacename):
 291         #
 292         # XXX: This bleeds the knowledge of iface
 293         # types in the infrastructure module.
 294         # Cant think of a better fix at the moment.
 295         # In future maybe the module can set a flag
 296         # to indicate if we should follow upperifaces
 297         #
 298         ifaceobj = self.get_ifaceobj_first(ifacename)
 299         if ifaceobj.type == ifaceType.BRIDGE_VLAN:
 300             return False
 301         return True
 302
 303     def create_n_save_ifaceobj(self, ifacename, priv_flags=None,
 304                                increfcnt=False):
 305         """ creates a iface object and adds it to the iface dictionary """
 306         ifaceobj = iface()
 307         ifaceobj.name = ifacename
 308         ifaceobj.priv_flags = priv_flags
 309         ifaceobj.auto = True
 310         if not self._link_master_slave:
 311             ifaceobj.link_type = ifaceLinkType.LINK_NA
 312         if increfcnt:
 313             ifaceobj.inc_refcnt()
 314         self.ifaceobjdict[ifacename] = [ifaceobj]
 315         return ifaceobj
 316
 317     def create_n_save_ifaceobjcurr(self, ifaceobj):
 318         """ creates a copy of iface object and adds it to the iface
 319             dict containing current iface objects
 320         """
 321         ifaceobjcurr = iface()
 322         ifaceobjcurr.name = ifaceobj.name
 323         ifaceobjcurr.type = ifaceobj.type
 324         ifaceobjcurr.lowerifaces = ifaceobj.lowerifaces
 325         ifaceobjcurr.priv_flags = ifaceobj.priv_flags
 326         ifaceobjcurr.auto = ifaceobj.auto
 327         self.ifaceobjcurrdict.setdefault(ifaceobj.name,
 328                                      []).append(ifaceobjcurr)
 329         return ifaceobjcurr
 330
 331     def get_ifaceobjcurr(self, ifacename, idx=0):
 332         ifaceobjlist = self.ifaceobjcurrdict.get(ifacename)
 333         if not ifaceobjlist:
 334             return None
 335         if not idx:
 336             return ifaceobjlist
 337         else:
 338             return ifaceobjlist[idx]
 339
 340     def get_ifaceobjrunning(self, ifacename):
 341         return self.ifaceobjrunningdict.get(ifacename)
 342
 343     def get_iface_refcnt(self, ifacename):
 344         """ Return iface ref count """
 345         max = 0
 346         ifaceobjs = self.get_ifaceobjs(ifacename)
 347         if not ifaceobjs:
 348             return 0
 349         for i in ifaceobjs:
 350             if i.refcnt > max:
 351                 max = i.refcnt
 352         return max
 353
 354     def is_iface_builtin_byname(self, ifacename):
 355         """ Returns true if iface name is a builtin interface.
 356
 357         A builtin interface is an interface which ifupdown understands.
 358         The following are currently considered builtin ifaces:
 359             - vlan interfaces in the format <ifacename>.<vlanid>
 360         """
 361         return '.' in ifacename
 362
 363     def is_ifaceobj_builtin(self, ifaceobj):
 364         """ Returns true if iface name is a builtin interface.
 365
 366         A builtin interface is an interface which ifupdown understands.
 367         The following are currently considered builtin ifaces:
 368             - vlan interfaces in the format <ifacename>.<vlanid>
 369         """
 370         return (ifaceobj.priv_flags & self.BUILTIN)
 371
 372     def is_ifaceobj_noconfig(self, ifaceobj):
 373         """ Returns true if iface object did not have a user defined config.
 374
 375         These interfaces appear only when they are dependents of interfaces
 376         which have user defined config
 377         """
 378         return (ifaceobj.priv_flags & self.NOCONFIG)
 379
 380     def is_iface_noconfig(self, ifacename):
 381         """ Returns true if iface has no config """
 382
 383         ifaceobj = self.get_ifaceobj_first(ifacename)
 384         if not ifaceobj: return True
 385         return self.is_ifaceobj_noconfig(ifaceobj)
 386
 387     def check_shared_dependents(self, ifaceobj, dlist):
 388         """ Check if dlist intersects with any other
 389             interface with slave dependents.
 390             example: bond and bridges.
 391             This function logs such errors """
 392         setdlist = Set(dlist)
 393         for ifacename, ifacedlist in self.dependency_graph.items():
 394             if not ifacedlist:
 395                 continue
 396             check_depends = False
 397             iobjs = self.get_ifaceobjs(ifacename)
 398             for i in iobjs:
 399                 if (i.dependency_type == ifaceDependencyType.MASTER_SLAVE):
 400                     check_depends = True
 401             if check_depends:
 402                 common = Set(ifacedlist).intersection(setdlist)
 403                 if common:
 404                     self.logger.error('misconfig..?. iface %s and %s '
 405                             %(ifaceobj.name, ifacename) +
 406                             'seem to share dependents/ports %s' %str(list(common)))
 407
 408     def preprocess_dependency_list(self, upperifaceobj, dlist, ops):
 409         """ We go through the dependency list and
 410             delete or add interfaces from the interfaces dict by
 411             applying the following rules:
 412                 if flag _DELETE_DEPENDENT_IFACES_WITH_NOCONFIG is True:
 413                     we only consider devices whose configuration was
 414                     specified in the network interfaces file. We delete
 415                     any interface whose config was not specified except
 416                     for vlan devices. vlan devices get special treatment.
 417                     Even if they are not present they are created and added
 418                     to the ifacesdict
 419                 elif flag _DELETE_DEPENDENT_IFACES_WITH_NOCONFIG is False:
 420                     we create objects for all dependent devices that are not
 421                     present in the ifacesdict
 422         """
 423         del_list = []
 424
 425         if (upperifaceobj.dependency_type ==
 426                     ifaceDependencyType.MASTER_SLAVE):
 427             self.check_shared_dependents(upperifaceobj, dlist)
 428
 429         for d in dlist:
 430             dilist = self.get_ifaceobjs(d)
 431             if not dilist:
 432                 ni = None
 433                 if self.is_iface_builtin_byname(d):
 434                     ni = self.create_n_save_ifaceobj(d,
 435                             self.BUILTIN | self.NOCONFIG, True)
 436                 elif not self._DELETE_DEPENDENT_IFACES_WITH_NOCONFIG:
 437                     ni = self.create_n_save_ifaceobj(d, self.NOCONFIG,
 438                             True)
 439                 else:
 440                     del_list.append(d)
 441                 if ni:
 442                     if upperifaceobj.link_kind & \
 443                            (ifaceLinkKind.BOND | ifaceLinkKind.BRIDGE):
 444                         ni.role |= ifaceRole.SLAVE
 445                     ni.add_to_upperifaces(upperifaceobj.name)
 446                     if upperifaceobj.link_type == ifaceLinkType.LINK_MASTER:
 447                         ni.link_type = ifaceLinkType.LINK_SLAVE
 448             else:
 449                 for di in dilist:
 450                     di.inc_refcnt()
 451                     di.add_to_upperifaces(upperifaceobj.name)
 452                     if upperifaceobj.link_kind & \
 453                            (ifaceLinkKind.BOND | ifaceLinkKind.BRIDGE):
 454                         di.role |= ifaceRole.SLAVE
 455                     if upperifaceobj.link_type == ifaceLinkType.LINK_MASTER:
 456                         di.link_type = ifaceLinkType.LINK_SLAVE
 457         for d in del_list:
 458             dlist.remove(d)
 459
 460     def query_dependents(self, ifaceobj, ops, ifacenames, type=None):
 461         """ Gets iface dependents by calling into respective modules """
 462         ret_dlist = []
 463
 464         # Get dependents for interface by querying respective modules
 465         for module in self.modules.values():
 466             try:
 467                 if ops[0] == 'query-running':
 468                     if (not hasattr(module,
 469                         'get_dependent_ifacenames_running')):
 470                         continue
 471                     dlist = module.get_dependent_ifacenames_running(ifaceobj)
 472                 else:
 473                     if (not hasattr(module, 'get_dependent_ifacenames')):
 474                         continue
 475                     dlist = module.get_dependent_ifacenames(ifaceobj,
 476                                         ifacenames)
 477             except Exception, e:
 478                 self.logger.warn('%s: error getting dependent interfaces (%s)'
 479                         %(ifaceobj.name, str(e)))
 480                 dlist = None
 481                 pass
 482             if dlist: ret_dlist.extend(dlist)
 483         return list(set(ret_dlist))
 484
 485
 486     def populate_dependency_info(self, ops, ifacenames=None):
 487         """ recursive function to generate iface dependency info """
 488
 489         if not ifacenames:
 490             ifacenames = self.ifaceobjdict.keys()
 491
 492         iqueue = deque(ifacenames)
 493         while iqueue:
 494             i = iqueue.popleft()
 495             # Go through all modules and find dependent ifaces
 496             dlist = None
 497             ifaceobj = self.get_ifaceobj_first(i)
 498             if not ifaceobj:
 499                 continue
 500             if ifaceobj.blacklisted:
 501                 continue
 502             dlist = ifaceobj.lowerifaces
 503             if not dlist:
 504                 dlist = self.query_dependents(ifaceobj, ops, ifacenames)
 505             else:
 506                 continue
 507             if dlist:
 508                 self.preprocess_dependency_list(ifaceobj,
 509                                                 dlist, ops)
 510                 ifaceobj.lowerifaces = dlist
 511                 [iqueue.append(d) for d in dlist]
 512             if not self.dependency_graph.get(i):
 513                 self.dependency_graph[i] = dlist
 514
 515     def _check_config_no_repeats(self, ifaceobj):
 516         """ check if object has an attribute that is
 517         restricted to a single object in the system.
 518         if yes, warn and return """
 519         for k,v in self._cache_no_repeats.items():
 520             iv = ifaceobj.config.get(k)
 521             if iv and iv[0] == v:
 522                 self.logger.error('ignoring interface %s. ' %ifaceobj.name +
 523                         'Only one object with attribute ' +
 524                         '\'%s %s\' allowed.' %(k, v))
 525                 return True
 526         for k, v in self.config.get('no_repeats', {}).items():
 527             iv = ifaceobj.config.get(k)
 528             if iv and iv[0] == v:
 529                 self._cache_no_repeats[k] = v
 530         return False
 531
 532     def _save_iface(self, ifaceobj):
 533         if self._check_config_no_repeats(ifaceobj):
 534            return
 535         if not self._link_master_slave:
 536            ifaceobj.link_type = ifaceLinkType.LINK_NA
 537         currentifaceobjlist = self.ifaceobjdict.get(ifaceobj.name)
 538         if not currentifaceobjlist:
 539            self.ifaceobjdict[ifaceobj.name]= [ifaceobj]
 540            return
 541         if ifaceobj.compare(currentifaceobjlist[0]):
 542             self.logger.warn('duplicate interface %s found' %ifaceobj.name)
 543             return
 544         if currentifaceobjlist[0].type == ifaceobj.type:
 545             currentifaceobjlist[0].flags |= iface.HAS_SIBLINGS
 546             ifaceobj.flags |= iface.HAS_SIBLINGS
 547         self.ifaceobjdict[ifaceobj.name].append(ifaceobj)
 548
 549     def _iface_configattr_syntax_checker(self, attrname, attrval):
 550         for m, mdict in self.module_attrs.items():
 551             if not mdict:
 552                 continue
 553             attrsdict = mdict.get('attrs')
 554             try:
 555                 if attrsdict.get(attrname):
 556                     return True
 557             except AttributeError:
 558                 pass
 559         return False
 560
 561     def _ifaceobj_syntax_checker(self, ifaceobj):
 562         err = False
 563         for attrname, attrvalue in ifaceobj.config.items():
 564             found = False
 565             for k, v in self.module_attrs.items():
 566                 if v and v.get('attrs', {}).get(attrname):
 567                     found = True
 568                     break
 569             if not found:
 570                 err = True
 571                 self.logger.warn('%s: unsupported attribute \'%s\'' \
 572                                  % (ifaceobj.name, attrname))
 573                 continue
 574         return err
 575
 576     def read_iface_config(self):
 577         """ Reads default network interface config /etc/network/interfaces. """
 578         nifaces = networkInterfaces(self.interfacesfile,
 579                         self.interfacesfileiobuf,
 580                         self.interfacesfileformat,
 581                         template_engine=self.config.get('template_engine'),
 582                 template_lookuppath=self.config.get('template_lookuppath'))
 583         nifaces.subscribe('iface_found', self._save_iface)
 584         nifaces.subscribe('validateifaceattr',
 585                           self._iface_configattr_syntax_checker)
 586         nifaces.subscribe('validateifaceobj', self._ifaceobj_syntax_checker)
 587         nifaces.load()
 588
 589     def read_old_iface_config(self):
 590         """ Reads the saved iface config instead of default iface config.
 591         And saved iface config is already read by the statemanager """
 592         self.ifaceobjdict = copy.deepcopy(self.statemanager.ifaceobjdict)
 593
 594     def _load_addon_modules_config(self):
 595         """ Load addon modules config file """
 596
 597         with open(self.addon_modules_configfile, 'r') as f:
 598             lines = f.readlines()
 599             for l in lines:
 600                 try:
 601                     litems = l.strip(' \n\t\r').split(',')
 602                     if not litems or len(litems) < 2:
 603                         continue
 604                     operation = litems[0]
 605                     mname = litems[1]
 606                     self.module_ops[operation].append(mname)
 607                 except Exception, e:
 608                     self.logger.warn('error reading line \'%s\'' %(l, str(e)))
 609                     continue
 610
 611     def load_addon_modules(self, modules_dir):
 612         """ load python modules from modules_dir
 613
 614         Default modules_dir is /usr/share/ifupdownmodules
 615
 616         """
 617         self.logger.info('loading builtin modules from %s' %modules_dir)
 618         self._load_addon_modules_config()
 619         if not modules_dir in sys.path:
 620             sys.path.append(modules_dir)
 621         try:
 622             for op, mlist in self.module_ops.items():
 623                 for mname in mlist:
 624                     if self.modules.get(mname):
 625                         continue
 626                     mpath = modules_dir + '/' + mname + '.py'
 627                     if os.path.exists(mpath):
 628                         try:
 629                             m = __import__(mname)
 630                             mclass = getattr(m, mname)
 631                         except:
 632                             raise
 633                         minstance = mclass(force=self.FORCE,
 634                                         dryrun=self.DRYRUN,
 635                                         nowait=self.NOWAIT,
 636                                         perfmode=self.PERFMODE,
 637                                         cache=self.CACHE,
 638                                         cacheflags=self.CACHE_FLAGS)
 639                         self.modules[mname] = minstance
 640                         try:
 641                             self.module_attrs[mname] = minstance.get_modinfo()
 642                         except:
 643                             pass
 644         except:
 645             raise
 646
 647         # Assign all modules to query operations
 648         self.module_ops['query-checkcurr'] = self.modules.keys()
 649         self.module_ops['query-running'] = self.modules.keys()
 650         self.module_ops['query-dependency'] = self.modules.keys()
 651         self.module_ops['query'] = self.modules.keys()
 652         self.module_ops['query-raw'] = self.modules.keys()
 653
 654
 655     def _modules_help(self):
 656         """ Prints addon modules supported syntax """
 657
 658         indent = '  '
 659         for m, mdict in self.module_attrs.items():
 660             if not mdict:
 661                 continue
 662             print('%s: %s' %(m, mdict.get('mhelp')))
 663             attrdict = mdict.get('attrs')
 664             if not attrdict:
 665                 continue
 666             try:
 667                 for attrname, attrvaldict in attrdict.items():
 668                     if attrvaldict.get('compat', False):
 669                         continue
 670                     print('%s%s' %(indent, attrname))
 671                     print('%shelp: %s' %(indent + '  ',
 672                           attrvaldict.get('help', '')))
 673                     print ('%srequired: %s' %(indent + '  ',
 674                             attrvaldict.get('required', False)))
 675                     default = attrvaldict.get('default')
 676                     if default:
 677                         print('%sdefault: %s' %(indent + '  ', default))
 678
 679                     validrange = attrvaldict.get('validrange')
 680                     if validrange:
 681                         print('%svalidrange: %s-%s'
 682                               %(indent + '  ', validrange[0], validrange[1]))
 683
 684                     validvals = attrvaldict.get('validvals')
 685                     if validvals:
 686                         print('%svalidvals: %s'
 687                               %(indent + '  ', ','.join(validvals)))
 688
 689                     examples = attrvaldict.get('example')
 690                     if not examples:
 691                         continue
 692
 693                     print '%sexample:' %(indent + '  ')
 694                     for e in examples:
 695                         print '%s%s' %(indent + '    ', e)
 696             except:
 697                 pass
 698             print ''
 699
 700     def load_scripts(self, modules_dir):
 701         """ loading user modules from /etc/network/.
 702
 703         Note that previously loaded python modules override modules found
 704         under /etc/network if any
 705
 706         """
 707
 708         self.logger.info('looking for user scripts under %s' %modules_dir)
 709         for op, mlist in self.script_ops.items():
 710             msubdir = modules_dir + '/if-%s.d' %op
 711             self.logger.info('loading scripts under %s ...' %msubdir)
 712             try:
 713                 module_list = os.listdir(msubdir)
 714                 for module in module_list:
 715                     if  self.modules.get(module) is not None:
 716                         continue
 717                     self.script_ops[op].append(
 718                                     msubdir + '/' + module)
 719             except:
 720                 # continue reading
 721                 pass
 722
 723     def _sched_ifaces(self, ifacenames, ops, skipupperifaces=False,
 724                       followdependents=True, sort=False):
 725         self.logger.debug('scheduling \'%s\' for %s'
 726                           %(str(ops), str(ifacenames)))
 727         self._pretty_print_ordered_dict('dependency graph',
 728                     self.dependency_graph)
 729         return ifaceScheduler.sched_ifaces(self, ifacenames, ops,
 730                         dependency_graph=self.dependency_graph,
 731                         order=ifaceSchedulerFlags.INORDER
 732                             if 'down' in ops[0]
 733                                 else ifaceSchedulerFlags.POSTORDER,
 734                         followdependents=followdependents,
 735                         skipupperifaces=skipupperifaces,
 736                         sort=True if (sort or self.IFACE_CLASS) else False)
 737
 738     def _render_ifacename(self, ifacename):
 739         new_ifacenames = []
 740         vlan_match = re.match("^([\d]+)-([\d]+)", ifacename)
 741         if vlan_match:
 742             vlan_groups = vlan_match.groups()
 743             if vlan_groups[0] and vlan_groups[1]:
 744                 [new_ifacenames.append('%d' %v)
 745                     for v in range(int(vlan_groups[0]),
 746                             int(vlan_groups[1])+1)]
 747         return new_ifacenames
 748
 749     def _preprocess_ifacenames(self, ifacenames):
 750         """ validates interface list for config existance.
 751
 752         returns -1 if one or more interface not found. else, returns 0
 753
 754         """
 755         new_ifacenames = []
 756         err_iface = ''
 757         for i in ifacenames:
 758             ifaceobjs = self.get_ifaceobjs(i)
 759             if not ifaceobjs:
 760                 # if name not available, render interface name and check again
 761                 rendered_ifacenames = utils.expand_iface_range(i)
 762                 if rendered_ifacenames:
 763                     for ri in rendered_ifacenames:
 764                         ifaceobjs = self.get_ifaceobjs(ri)
 765                         if not ifaceobjs:
 766                             err_iface += ' ' + ri
 767                         else:
 768                             new_ifacenames.append(ri)
 769                 else:
 770                     err_iface += ' ' + i
 771             else:
 772                 new_ifacenames.append(i)
 773         if err_iface:
 774             raise Exception('cannot find interfaces:%s' %err_iface)
 775         return new_ifacenames
 776
 777     def _iface_whitelisted(self, auto, allow_classes, excludepats, ifacename):
 778         """ Checks if interface is whitelisted depending on set of parameters.
 779
 780         interfaces are checked against the allow_classes and auto lists.
 781
 782         """
 783         ret = True
 784
 785         # Check if interface matches the exclude patter
 786         if excludepats:
 787             for e in excludepats:
 788                 if re.search(e, ifacename):
 789                     ret = False
 790         ifaceobjs = self.get_ifaceobjs(ifacename)
 791         if not ifaceobjs:
 792             if ret:
 793                 self.logger.debug('iface %s' %ifacename + ' not found')
 794             return ret
 795         # If matched exclude pattern, return false
 796         if not ret:
 797             for i in ifaceobjs:
 798                 i.blacklisted = True
 799             return ret
 800         # Check if interface belongs to the class
 801         # the user is interested in, if not return false
 802         if allow_classes:
 803             for i in ifaceobjs:
 804                 if i.classes:
 805                     common = Set([allow_classes]).intersection(
 806                                 Set(i.classes))
 807                     if common:
 808                         ret = True
 809                     else:
 810                         i.blacklisted = True
 811             if not ret:
 812                 return ret
 813         # If the user has requested auto class, check if the interface
 814         # is marked auto
 815         if auto:
 816             for i in ifaceobjs:
 817                 if i.auto:
 818                     ret = True
 819                 else:
 820                     i.blacklisted = True
 821         return ret
 822
 823     def _compat_conv_op_to_mode(self, op):
 824         """ Returns old op name to work with existing scripts """
 825         if op == 'pre-up':
 826             return 'start'
 827         elif op == 'pre-down':
 828             return 'stop'
 829         else:
 830             return op
 831
 832     def generate_running_env(self, ifaceobj, op):
 833         """ Generates a dictionary with env variables required for
 834         an interface. Used to support script execution for interfaces.
 835         """
 836
 837         cenv = None
 838         iface_env = ifaceobj.env
 839         if iface_env:
 840             cenv = os.environ
 841             if cenv:
 842                 cenv.update(iface_env)
 843             else:
 844                 cenv = iface_env
 845             cenv['MODE'] = self._compat_conv_op_to_mode(op)
 846         return cenv
 847
 848     def _save_state(self):
 849         if not self.STATEMANAGER_ENABLE or not self.STATEMANAGER_UPDATE:
 850             return
 851         try:
 852             # Update persistant iface states
 853             self.statemanager.save_state()
 854         except Exception, e:
 855             if self.logger.isEnabledFor(logging.DEBUG):
 856                 t = sys.exc_info()[2]
 857                 traceback.print_tb(t)
 858                 self.logger.warning('error saving state (%s)' %str(e))
 859
 860     def set_type(self, type):
 861         if type == 'iface':
 862             self.type = ifaceType.IFACE
 863         elif type == 'vlan':
 864             self.type = ifaceType.BRIDGE_VLAN
 865         else:
 866             self.type = ifaceType.UNKNOWN
 867
 868     def _process_delay_admin_state_queue(self, op):
 869         if not self._delay_admin_state_iface_queue:
 870            return
 871         if op == 'up':
 872            func = self.link_up
 873         elif op == 'down':
 874            func = self.link_down
 875         else:
 876            return
 877         for i in self._delay_admin_state_iface_queue:
 878             try:
 879                 if self.link_exists(i):
 880                    func(i)
 881             except Exception, e:
 882                 self.logger.warn(str(e))
 883                 pass
 884
 885     def up(self, ops, auto=False, allow_classes=None, ifacenames=None,
 886            excludepats=None, printdependency=None, syntaxcheck=False,
 887            type=None, skipupperifaces=False):
 888         """This brings the interface(s) up
 889
 890         Args:
 891             ops (list): list of ops to perform on the interface(s).
 892             Eg: ['pre-up', 'up', 'post-up'
 893
 894         Kwargs:
 895             auto (bool): act on interfaces marked auto
 896             allow_classes (list): act on interfaces belonging to classes in the list
 897             ifacenames (list): act on interfaces specified in this list
 898             excludepats (list): list of patterns of interfaces to exclude
 899             syntaxcheck (bool): only perform syntax check
 900         """
 901
 902         self.set_type(type)
 903
 904         if allow_classes:
 905             self.IFACE_CLASS = True
 906         if not self.ADDONS_ENABLE: self.STATEMANAGER_UPDATE = False
 907         if auto:
 908             self.ALL = True
 909             self.WITH_DEPENDS = True
 910         try:
 911             self.read_iface_config()
 912         except Exception:
 913             raise
 914
 915         # If only syntax check was requested, return here
 916         if syntaxcheck:
 917             return
 918
 919         if ifacenames:
 920             ifacenames = self._preprocess_ifacenames(ifacenames)
 921
 922         # if iface list not given by user, assume all from config file
 923         if not ifacenames: ifacenames = self.ifaceobjdict.keys()
 924
 925         # filter interfaces based on auto and allow classes
 926         filtered_ifacenames = [i for i in ifacenames
 927                                if self._iface_whitelisted(auto, allow_classes,
 928                                                 excludepats, i)]
 929         if not filtered_ifacenames:
 930             raise Exception('no ifaces found matching given allow lists')
 931
 932         if printdependency:
 933             self.populate_dependency_info(ops, filtered_ifacenames)
 934             self.print_dependency(filtered_ifacenames, printdependency)
 935             return
 936         else:
 937             self.populate_dependency_info(ops)
 938
 939         try:
 940             self._sched_ifaces(filtered_ifacenames, ops,
 941                     skipupperifaces=skipupperifaces,
 942                     followdependents=True if self.WITH_DEPENDS else False)
 943         finally:
 944             self._process_delay_admin_state_queue('up')
 945             if not self.DRYRUN and self.ADDONS_ENABLE:
 946                 self._save_state()
 947
 948     def down(self, ops, auto=False, allow_classes=None, ifacenames=None,
 949              excludepats=None, printdependency=None, usecurrentconfig=False,
 950              type=None):
 951         """ down an interface """
 952
 953         self.set_type(type)
 954
 955         if allow_classes:
 956             self.IFACE_CLASS = True
 957         if not self.ADDONS_ENABLE: self.STATEMANAGER_UPDATE = False
 958         if auto:
 959             self.ALL = True
 960             self.WITH_DEPENDS = True
 961         # For down we need to look at old state, unless usecurrentconfig
 962         # is set
 963         if (not usecurrentconfig and self.STATEMANAGER_ENABLE and
 964                     self.statemanager.ifaceobjdict):
 965             # Since we are using state manager objects,
 966             # skip the updating of state manager objects
 967             self.logger.debug('Looking at old state ..')
 968             self.read_old_iface_config()
 969         else:
 970             # If no old state available
 971             try:
 972                 self.read_iface_config()
 973             except Exception, e:
 974                 raise Exception('error reading iface config (%s)' %str(e))
 975         if ifacenames:
 976             # If iface list is given by the caller, always check if iface
 977             # is present
 978             try:
 979                ifacenames = self._preprocess_ifacenames(ifacenames)
 980             except Exception, e:
 981                raise Exception('%s' %str(e) +
 982                        ' (interface was probably never up ?)')
 983
 984         # if iface list not given by user, assume all from config file
 985         if not ifacenames: ifacenames = self.ifaceobjdict.keys()
 986
 987         # filter interfaces based on auto and allow classes
 988         filtered_ifacenames = [i for i in ifacenames
 989                                if self._iface_whitelisted(auto, allow_classes,
 990                                                 excludepats, i)]
 991         if not filtered_ifacenames:
 992             raise Exception('no ifaces found matching given allow lists ' +
 993                     '(or interfaces were probably never up ?)')
 994
 995         if printdependency:
 996             self.populate_dependency_info(ops, filtered_ifacenames)
 997             self.print_dependency(filtered_ifacenames, printdependency)
 998             return
 999         else:
1000             self.populate_dependency_info(ops)
1001
1002         try:
1003             self._sched_ifaces(filtered_ifacenames, ops,
1004                     followdependents=True if self.WITH_DEPENDS else False)
1005         finally:
1006             self._process_delay_admin_state_queue('down')
1007             if not self.DRYRUN and self.ADDONS_ENABLE:
1008                 self._save_state()
1009
1010     def query(self, ops, auto=False, allow_classes=None, ifacenames=None,
1011               excludepats=None, printdependency=None,
1012               format='native', type=None):
1013         """ query an interface """
1014
1015         self.set_type(type)
1016
1017         if allow_classes:
1018             self.IFACE_CLASS = True
1019         if self.STATEMANAGER_ENABLE and ops[0] == 'query-savedstate':
1020             return self.statemanager.dump_pretty(ifacenames)
1021         self.STATEMANAGER_UPDATE = False
1022         if auto:
1023             self.logger.debug('setting flag ALL')
1024             self.ALL = True
1025             self.WITH_DEPENDS = True
1026
1027         if ops[0] == 'query-syntax':
1028             self._modules_help()
1029             return
1030         elif ops[0] == 'query-running':
1031             # create fake devices to all dependents that dont have config
1032             map(lambda i: self.create_n_save_ifaceobj(i, self.NOCONFIG),
1033                     ifacenames)
1034         else:
1035             try:
1036                 self.read_iface_config()
1037             except Exception:
1038                 raise
1039
1040         if ifacenames and ops[0] != 'query-running':
1041            # If iface list is given, always check if iface is present
1042            ifacenames = self._preprocess_ifacenames(ifacenames)
1043
1044         # if iface list not given by user, assume all from config file
1045         if not ifacenames: ifacenames = self.ifaceobjdict.keys()
1046
1047         # filter interfaces based on auto and allow classes
1048         if ops[0] == 'query-running':
1049             filtered_ifacenames = ifacenames
1050         else:
1051             filtered_ifacenames = [i for i in ifacenames
1052                 if self._iface_whitelisted(auto, allow_classes,
1053                         excludepats, i)]
1054         if not filtered_ifacenames:
1055                 raise Exception('no ifaces found matching ' +
1056                         'given allow lists')
1057
1058         self.populate_dependency_info(ops)
1059         if ops[0] == 'query-dependency' and printdependency:
1060             self.print_dependency(filtered_ifacenames, printdependency)
1061             return
1062
1063         if ops[0] == 'query':
1064             return self.print_ifaceobjs_pretty(filtered_ifacenames, format)
1065         elif ops[0] == 'query-raw':
1066             return self.print_ifaceobjs_raw(filtered_ifacenames)
1067
1068         self._sched_ifaces(filtered_ifacenames, ops,
1069                            followdependents=True if self.WITH_DEPENDS else False)
1070
1071         if ops[0] == 'query-checkcurr':
1072             ret = self.print_ifaceobjscurr_pretty(filtered_ifacenames, format)
1073             if ret != 0:
1074                 # if any of the object has an error, signal that silently
1075                 raise Exception('')
1076         elif ops[0] == 'query-running':
1077             self.print_ifaceobjsrunning_pretty(filtered_ifacenames, format)
1078             return
1079
1080     def _reload_currentlyup(self, upops, downops, auto=True, allow=None,
1081             ifacenames=None, excludepats=None, usecurrentconfig=False,
1082             **extra_args):
1083         """ reload currently up interfaces """
1084         allow_classes = []
1085         new_ifaceobjdict = {}
1086
1087         # Override auto to true
1088         auto = True
1089         try:
1090             self.read_iface_config()
1091         except:
1092             raise
1093         if not self.ifaceobjdict:
1094             self.logger.warn("nothing to reload ..exiting.")
1095             return
1096         already_up_ifacenames = []
1097         # generate dependency graph of interfaces
1098         self.populate_dependency_info(upops)
1099         if (not usecurrentconfig and self.STATEMANAGER_ENABLE
1100                 and self.statemanager.ifaceobjdict):
1101             already_up_ifacenames = self.statemanager.ifaceobjdict.keys()
1102
1103         if not ifacenames: ifacenames = self.ifaceobjdict.keys()
1104         filtered_ifacenames = [i for i in ifacenames
1105                                if self._iface_whitelisted(auto, allow_classes,
1106                                excludepats, i)]
1107
1108         # Get already up interfaces that still exist in the interfaces file
1109         already_up_ifacenames_not_present = Set(
1110                         already_up_ifacenames).difference(ifacenames)
1111         already_up_ifacenames_still_present = Set(
1112                         already_up_ifacenames).difference(
1113                         already_up_ifacenames_not_present)
1114         interfaces_to_up = Set(already_up_ifacenames_still_present).union(
1115                                             filtered_ifacenames)
1116
1117         if (already_up_ifacenames_not_present and
1118                 self.config.get('ifreload_currentlyup_down_notpresent') == '1'):
1119            self.logger.info('reload: schedule down on interfaces: %s'
1120                             %str(already_up_ifacenames_not_present))
1121
1122            # Save a copy of new iface objects and dependency_graph
1123            new_ifaceobjdict = dict(self.ifaceobjdict)
1124            new_dependency_graph = dict(self.dependency_graph)
1125
1126            # old interface config is read into self.ifaceobjdict
1127            self.read_old_iface_config()
1128
1129            # reinitialize dependency graph
1130            self.dependency_graph = OrderedDict({})
1131            self.populate_dependency_info(downops,
1132                                          already_up_ifacenames_not_present)
1133            self._sched_ifaces(already_up_ifacenames_not_present, downops,
1134                               followdependents=False, sort=True)
1135         else:
1136            self.logger.debug('no interfaces to down ..')
1137
1138         # Now, run 'up' with new config dict
1139         # reset statemanager update flag to default
1140         if auto:
1141             self.ALL = True
1142             self.WITH_DEPENDS = True
1143         if new_ifaceobjdict:
1144             # and now, ifaceobjdict is back to current config
1145             self.ifaceobjdict = new_ifaceobjdict
1146             self.dependency_graph = new_dependency_graph
1147
1148         if not self.ifaceobjdict:
1149            return
1150         self.logger.info('reload: scheduling up on interfaces: %s'
1151                          %str(interfaces_to_up))
1152         self._sched_ifaces(interfaces_to_up, upops,
1153                 followdependents=True if self.WITH_DEPENDS else False)
1154         if self.DRYRUN:
1155             return
1156         self._save_state()
1157
1158     def _reload_default(self, upops, downops, auto=False, allow=None,
1159             ifacenames=None, excludepats=None, usecurrentconfig=False,
1160             **extra_args):
1161         """ reload interface config """
1162         allow_classes = []
1163         new_ifaceobjdict = {}
1164
1165         try:
1166             self.read_iface_config()
1167         except:
1168             raise
1169
1170         if not self.ifaceobjdict:
1171             self.logger.warn("nothing to reload ..exiting.")
1172             return
1173         # generate dependency graph of interfaces
1174         self.populate_dependency_info(upops)
1175         if (not usecurrentconfig and self.STATEMANAGER_ENABLE
1176                 and self.statemanager.ifaceobjdict):
1177             # Save a copy of new iface objects and dependency_graph
1178             new_ifaceobjdict = dict(self.ifaceobjdict)
1179             new_dependency_graph = dict(self.dependency_graph)
1180
1181             # if old state is present, read old state and mark op for 'down'
1182             # followed by 'up' aka: reload
1183             # old interface config is read into self.ifaceobjdict
1184             self.read_old_iface_config()
1185             op = 'reload'
1186         else:
1187             # oldconfig not available, continue with 'up' with new config
1188             op = 'up'
1189
1190         if not ifacenames: ifacenames = self.ifaceobjdict.keys()
1191         if op == 'reload' and ifacenames:
1192             filtered_ifacenames = [i for i in ifacenames
1193                                if self._iface_whitelisted(auto, allow_classes,
1194                                excludepats, i)]
1195
1196             # if config file had 'ifreload_down_changed' variable
1197             # set, also look for interfaces that changed to down them
1198             down_changed = int(self.config.get('ifreload_down_changed', '1'))
1199
1200             # Generate the interface down list
1201             # Interfaces that go into the down list:
1202             #   - interfaces that were present in last config and are not
1203             #     present in the new config
1204             #   - interfaces that were changed between the last and current
1205             #     config
1206             ifacedownlist = []
1207             for ifname in filtered_ifacenames:
1208                 lastifaceobjlist = self.ifaceobjdict.get(ifname)
1209                 objidx = 0
1210                 # If interface is not present in the new file
1211                 # append it to the down list
1212                 newifaceobjlist = new_ifaceobjdict.get(ifname)
1213                 if not newifaceobjlist:
1214                     ifacedownlist.append(ifname)
1215                     continue
1216                 if not down_changed:
1217                     continue
1218                 if len(newifaceobjlist) != len(lastifaceobjlist):
1219                     ifacedownlist.append(ifname)
1220                     continue
1221
1222                 # If interface has changed between the current file
1223                 # and the last installed append it to the down list
1224                 # compare object list
1225                 for objidx in range(0, len(lastifaceobjlist)):
1226                     oldobj = lastifaceobjlist[objidx]
1227                     newobj = newifaceobjlist[objidx]
1228                     if not newobj.compare(oldobj):
1229                         ifacedownlist.append(ifname)
1230                         continue
1231
1232             if ifacedownlist:
1233                 self.logger.info('reload: scheduling down on interfaces: %s'
1234                                   %str(ifacedownlist))
1235                 # reinitialize dependency graph
1236                 self.dependency_graph = OrderedDict({})
1237                 # Generate dependency info for old config
1238                 self.populate_dependency_info(downops, ifacedownlist)
1239                 try:
1240                     self._sched_ifaces(ifacedownlist, downops,
1241                                        followdependents=False,
1242                                        sort=True)
1243                 except Exception, e:
1244                     self.logger.error(str(e))
1245                     pass
1246                 finally:
1247                     self._process_delay_admin_state_queue('down')
1248             else:
1249                 self.logger.debug('no interfaces to down ..')
1250
1251         # Now, run 'up' with new config dict
1252         # reset statemanager update flag to default
1253         if not new_ifaceobjdict:
1254             return
1255
1256         if auto:
1257             self.ALL = True
1258             self.WITH_DEPENDS = True
1259         # and now, we are back to the current config in ifaceobjdict
1260         self.ifaceobjdict = new_ifaceobjdict
1261         self.dependency_graph = new_dependency_graph
1262         ifacenames = self.ifaceobjdict.keys()
1263         filtered_ifacenames = [i for i in ifacenames
1264                                if self._iface_whitelisted(auto, allow_classes,
1265                                excludepats, i)]
1266
1267         self.logger.info('reload: scheduling up on interfaces: %s'
1268                          %str(filtered_ifacenames))
1269         try:
1270             self._sched_ifaces(filtered_ifacenames, upops,
1271                     followdependents=True if self.WITH_DEPENDS else False)
1272         except Exception, e:
1273             self.logger.error(str(e))
1274             pass
1275         finally:
1276             self._process_delay_admin_state_queue('up')
1277         if self.DRYRUN:
1278             return
1279         self._save_state()
1280
1281     def reload(self, *args, **kargs):
1282         """ reload interface config """
1283         self.logger.debug('reloading interface config ..')
1284         if kargs.get('currentlyup', False):
1285             self._reload_currentlyup(*args, **kargs)
1286         else:
1287             self._reload_default(*args, **kargs)
1288
1289     def _pretty_print_ordered_dict(self, prefix, argdict):
1290         outbuf = prefix + ' {\n'
1291         for k, vlist in argdict.items():
1292             outbuf += '\t%s : %s\n' %(k, str(vlist))
1293         self.logger.debug(outbuf + '}')
1294
1295     def print_dependency(self, ifacenames, format):
1296         """ prints iface dependency information """
1297
1298         if not ifacenames:
1299             ifacenames = self.ifaceobjdict.keys()
1300         if format == 'list':
1301             for k,v in self.dependency_graph.items():
1302                 print '%s : %s' %(k, str(v))
1303         elif format == 'dot':
1304             indegrees = {}
1305             map(lambda i: indegrees.update({i :
1306                 self.get_iface_refcnt(i)}),
1307                 self.dependency_graph.keys())
1308             graph.generate_dots(self.dependency_graph, indegrees)
1309
1310     def print_ifaceobjs_raw(self, ifacenames):
1311         """ prints raw lines for ifaces from config file """
1312
1313         for i in ifacenames:
1314             for ifaceobj in self.get_ifaceobjs(i):
1315                 if (self.is_ifaceobj_builtin(ifaceobj) or
1316                     not ifaceobj.is_config_present()):
1317                     continue
1318                 ifaceobj.dump_raw(self.logger)
1319                 print '\n'
1320                 if self.WITH_DEPENDS and not self.ALL:
1321                     dlist = ifaceobj.lowerifaces
1322                     if not dlist: continue
1323                     self.print_ifaceobjs_raw(dlist)
1324
1325     def _get_ifaceobjs_pretty(self, ifacenames, ifaceobjs, running=False):
1326         """ returns iface obj list """
1327
1328         for i in ifacenames:
1329             for ifaceobj in self.get_ifaceobjs(i):
1330                 if ((not running and self.is_ifaceobj_noconfig(ifaceobj)) or
1331                     (running and not ifaceobj.is_config_present())):
1332                     continue
1333                 ifaceobjs.append(ifaceobj)
1334                 if self.WITH_DEPENDS and not self.ALL:
1335                     dlist = ifaceobj.lowerifaces
1336                     if not dlist: continue
1337                     self._get_ifaceobjs_pretty(dlist, ifaceobjs, running)
1338
1339     def print_ifaceobjs_pretty(self, ifacenames, format='native'):
1340         """ pretty prints iface in format given by keyword arg format """
1341
1342         ifaceobjs = []
1343         self._get_ifaceobjs_pretty(ifacenames, ifaceobjs)
1344         if not ifaceobjs: return
1345         if format == 'json':
1346             print json.dumps(ifaceobjs, cls=ifaceJsonEncoder,
1347                              indent=4, separators=(',', ': '))
1348         else:
1349             expand = int(self.config.get('ifquery_ifacename_expand_range', '0'))
1350             for i in ifaceobjs:
1351                 if not expand and (i.flags & iface.IFACERANGE_ENTRY):
1352                     # print only the first one
1353                     if i.flags & iface.IFACERANGE_START:
1354                        i.dump_pretty(use_realname=True)
1355                 else:
1356                     i.dump_pretty()
1357
1358     def _get_ifaceobjscurr_pretty(self, ifacenames, ifaceobjs):
1359         ret = 0
1360         for i in ifacenames:
1361             ifaceobjscurr = self.get_ifaceobjcurr(i)
1362             if not ifaceobjscurr: continue
1363             for ifaceobj in ifaceobjscurr:
1364                 if (ifaceobj.status == ifaceStatus.NOTFOUND or
1365                     ifaceobj.status == ifaceStatus.ERROR):
1366                     ret = 1
1367                 if self.is_ifaceobj_noconfig(ifaceobj):
1368                     continue
1369                 ifaceobjs.append(ifaceobj)
1370                 if self.WITH_DEPENDS and not self.ALL:
1371                     dlist = ifaceobj.lowerifaces
1372                     if not dlist: continue
1373                     dret = self._get_ifaceobjscurr_pretty(dlist, ifaceobjs)
1374                     if dret: ret = 1
1375         return ret
1376
1377     def print_ifaceobjscurr_pretty(self, ifacenames, format='native'):
1378         """ pretty prints current running state of interfaces with status.
1379
1380         returns 1 if any of the interface has an error,
1381         else returns 0
1382         """
1383
1384         ifaceobjs = []
1385         ret = self._get_ifaceobjscurr_pretty(ifacenames, ifaceobjs)
1386         if not ifaceobjs: return
1387         if format == 'json':
1388             print json.dumps(ifaceobjs, cls=ifaceJsonEncoder, indent=2,
1389                        separators=(',', ': '))
1390         else:
1391             map(lambda i: i.dump_pretty(with_status=True,
1392                    successstr=self.config.get('ifquery_check_success_str',
1393                                               _success_sym),
1394                    errorstr=self.config.get('ifquery_check_error_str', _error_sym),
1395                    unknownstr=self.config.get('ifquery_check_unknown_str', '')),
1396                    ifaceobjs)
1397         return ret
1398
1399     def print_ifaceobjsrunning_pretty(self, ifacenames, format='native'):
1400         """ pretty prints iface running state """
1401
1402         ifaceobjs = []
1403         self._get_ifaceobjs_pretty(ifacenames, ifaceobjs, running=True)
1404         if not ifaceobjs: return
1405         if format == 'json':
1406             print json.dumps(ifaceobjs, cls=ifaceJsonEncoder, indent=2,
1407                        separators=(',', ': '))
1408         else:
1409             map(lambda i: i.dump_pretty(), ifaceobjs)
1410
1411     def _dump(self):
1412         print 'ifupdown main object dump'
1413         print self.pp.pprint(self.modules)
1414         print self.pp.pprint(self.ifaceobjdict)
1415
1416     def _dump_ifaceobjs(self, ifacenames):
1417         for i in ifacenames:
1418             ifaceobjs = self.get_ifaceobjs(i)
1419             for i in ifaceobjs:
1420                 i.dump(self.logger)
1421                 print '\n'