pkg/iface.py

   1 #!/usr/bin/python
   2 #
   3 # Copyright 2013.  Cumulus Networks, Inc.
   4 # Author: Roopa Prabhu, roopa@cumulusnetworks.com
   5 #
   6 # iface --
   7 #    interface object
   8 #
   9
  10 import logging
  11 import json
  12
  13 class ifaceFlags():
  14
  15     NONE = 0x1
  16     FOLLOW_DEPENDENTS = 0x2
  17
  18 class ifaceStatus():
  19
  20     """iface status """
  21     UNKNOWN = 0x1
  22     SUCCESS = 0x2
  23     ERROR = 0x3
  24     NOTFOUND = 0x4
  25
  26     @classmethod
  27     def to_str(cls, state):
  28         if state == cls.UNKNOWN:
  29             return 'unknown'
  30         elif state == cls.SUCCESS:
  31             return 'success'
  32         elif state == cls.ERROR:
  33             return 'error'
  34
  35     @classmethod
  36     def from_str(cls, state_str):
  37         if state_str == 'unknown':
  38             return cls.UNKNOWN
  39         elif state_str == 'success':
  40             return cls.SUCCESS
  41         elif state_str == 'error':
  42             return cls.ERROR
  43
  44 class ifaceState():
  45
  46     """ iface states """
  47     UNKNOWN = 0x1
  48     NEW = 0x2
  49     PRE_UP = 0x3
  50     UP = 0x4
  51     POST_UP = 0x5
  52     PRE_DOWN = 0x6
  53     DOWN = 0x7
  54     POST_DOWN = 0x8
  55
  56     @classmethod
  57     def to_str(cls, state):
  58         if state == cls.UNKNOWN:
  59             return 'unknown'
  60         elif state == cls.NEW:
  61             return 'new'
  62         elif state == cls.PRE_UP:
  63             return 'pre-up'
  64         elif state == cls.UP:
  65             return 'up'
  66         elif state == cls.POST_UP:
  67             return 'post-up'
  68         elif state == cls.PRE_DOWN:
  69             return 'pre-down'
  70         elif state == cls.POST_DOWN:
  71             return 'post-down'
  72
  73     @classmethod
  74     def from_str(cls, state_str):
  75         if state_str == 'unknown':
  76             return cls.UNKNOWN
  77         elif state_str == 'new':
  78             return cls.NEW
  79         elif state_str == 'pre-up':
  80             return cls.PRE_UP
  81         elif state_str == 'up':
  82             return cls.UP
  83         elif state_str == 'post-up':
  84             return cls.POST_UP
  85         elif state_str == 'pre-down':
  86             return cls.PRE_DOWN
  87         elif state_str == 'post-down':
  88             return cls.POST_DOWN
  89
  90
  91 class iface():
  92     """ config flags """
  93     AUTO = 0x1
  94     HOT_PLUG = 0x2
  95
  96
  97     def __init__(self):
  98         self.name = None
  99         self.addr_family = None
 100         self.addr_method = None
 101         self.config = {}
 102         self.children = []
 103         self.state = ifaceState.NEW
 104         self.status = ifaceStatus.UNKNOWN
 105         self.flags = 0x0
 106         self.refcnt = 0
 107         self.dependents = None
 108         self.auto = False
 109         self.classes = []
 110         self.env = None
 111         self.config_current = {}
 112         self.raw_lines = []
 113         self.linkstate = None
 114
 115     def inc_refcnt(self):
 116         #print 'inside inc_refcnt = %d' %self.refcnt
 117         self.refcnt += 1
 118
 119     def dec_refcnt(self):
 120         self.refcnt -= 1
 121
 122     def get_refcnt(self):
 123         return self.refcnt
 124
 125     def set_refcnt(self, cnt):
 126         self.refcnt = 0
 127
 128     def set_name(self, name):
 129         self.name = name
 130
 131     def get_name(self):
 132         return self.name
 133
 134     def set_addr_family(self, family):
 135         self.addr_family = family
 136
 137     def get_addr_family(self):
 138         return self.addr_family
 139
 140     def set_addr_method(self, method):
 141         self.addr_method = method
 142
 143     def get_addr_method(self):
 144         return self.addr_method
 145
 146     def set_config(self, config_dict):
 147         self.config = config_dict
 148
 149     def get_config(self):
 150         return self.config
 151
 152     def set_config_current(self, config_current):
 153         self.config_current = config_current
 154
 155     def get_config_current(self):
 156         return self.config_current
 157
 158     def get_auto(self):
 159         return self.auto
 160
 161     def set_auto(self):
 162         self.auto = True
 163
 164     def reset_auto(self):
 165         self.auto = False
 166
 167     def get_classes(self):
 168         return self.classes
 169
 170     def set_classes(self, classes):
 171         """ sets interface class list to the one passed as arg """
 172         self.classes = classes
 173
 174     def set_class(self, classname):
 175         """ Appends a class to the list """
 176         self.classes.append(classname)
 177
 178     def belongs_to_class(self, intfclass):
 179         if intfclass in self.classes:
 180             return True
 181
 182         return False
 183
 184     def add_child(self, child_iface_obj):
 185         self.children.append(child_iface_obj)
 186
 187     def get_state(self):
 188         return self.state
 189
 190     def get_state_str(self):
 191         return ifaceState.to_str(self.state)
 192
 193     def set_state(self, state):
 194         self.state = state
 195
 196     def get_status(self):
 197         return self.status
 198
 199     def get_status_str(self):
 200         return ifaceStatus.to_str(self.status)
 201
 202     def set_status(self, status):
 203         self.status = status
 204
 205     def state_str_to_hex(self, state_str):
 206         return self.state_str_map.get(state_str)
 207
 208     def set_flag(self, flag):
 209         self.flags |= flag
 210
 211     def clear_flag(self, flag):
 212         self.flags &= ~flag
 213
 214     def set_dependents(self, dlist):
 215         self.dependents = dlist
 216
 217     def get_dependents(self):
 218         return self.dependents
 219
 220     def set_linkstate(self, l):
 221         self.linkstate = l
 222
 223     def get_linkstate(self):
 224         return self.linkstate
 225
 226     def get_attr_value(self, attr_name):
 227         config = self.get_config()
 228
 229         return config.get(attr_name)
 230
 231     def get_attr_value_first(self, attr_name):
 232         config = self.get_config()
 233
 234         attr_value_list = config.get(attr_name)
 235         if attr_value_list is not None:
 236             return attr_value_list[0]
 237
 238         return None
 239
 240     def get_attr_value_n(self, attr_name, attr_index):
 241         config = self.get_config()
 242
 243         attr_value_list = config.get(attr_name)
 244         if attr_value_list is not None:
 245             try:
 246                 return attr_value_list[attr_index]
 247             except:
 248                 return None
 249
 250         return None
 251
 252     def get_env(self):
 253         if self.env is None or len(self.env) == 0:
 254             self.generate_env()
 255         return self.env
 256
 257     def set_env(self, env):
 258         self.env = env
 259
 260     def generate_env(self):
 261         env = {}
 262         config = self.get_config()
 263         env['IFACE'] = self.get_name()
 264         for attr, attr_value in config.items():
 265             attr_env_name = 'IF_%s' %attr.upper()
 266             env[attr_env_name] = attr_value[0]
 267
 268         if len(env) > 0:
 269             self.set_env(env)
 270
 271     def update_config(self, attr_name, attr_value, attr_status=0):
 272         if attr_value is None:
 273             attr_value = ''
 274
 275         if attr_status != 0:
 276             self.set_status(ifaceStatus.ERROR)
 277         else:
 278             if self.get_status() != ifaceStatus.ERROR:
 279                 self.set_status(ifaceStatus.SUCCESS)
 280         if self.config.get(attr_name) is not None:
 281             self.config[attr_name].append(attr_value)
 282         else:
 283             self.config[attr_name] = [attr_value]
 284
 285         """ XXX: If status needs to be encoded in the query string
 286         if attr_status == 0:
 287             self.set_status(attr
 288             attr_status_str = ''
 289         elif attr_status == 0:
 290             attr_status_str = ' (success)'
 291         elif attr_status != 0:
 292             attr_status_str = ' (error)'
 293         self.config[attr_name] = attr_value + attr_status_str """
 294
 295     def dump_raw(self, logger):
 296         indent = '  '
 297         print (self.raw_lines[0])
 298         for i in range(1, len(self.raw_lines)):
 299             print (indent + self.raw_lines[i])
 300
 301     def dump(self, logger):
 302         indent = '\t'
 303         logger.info(self.get_name() + ' : {')
 304         logger.info(indent + 'family: %s' %self.get_addr_family())
 305         logger.info(indent + 'method: %s' %self.get_addr_method())
 306         logger.info(indent + 'state: %s'
 307                 %ifaceState.to_str(self.get_state()))
 308         logger.info(indent + 'status: %s'
 309                 %ifaceStatus.to_str(self.get_status()))
 310         logger.info(indent + 'refcnt: %d' %self.get_refcnt())
 311         d = self.get_dependents()
 312         if d is not None:
 313             logger.info(indent + 'dependents: %s' %str(d))
 314         else:
 315             logger.info(indent + 'dependents: None')
 316
 317         logger.info(indent + 'config: ')
 318         config = self.get_config()
 319         if config is not None:
 320             logger.info(indent + indent + str(config))
 321         logger.info('}')
 322
 323     def dump_pretty(self, logger):
 324         indent = '\t'
 325         outbuf = 'iface %s' %self.get_name()
 326         if self.get_addr_family() is not None:
 327             outbuf += ' %s' %self.get_addr_family()
 328
 329         if self.get_addr_method() is not None:
 330             outbuf += ' %s' %self.get_addr_method()
 331
 332         outbuf += '\n'
 333
 334         config = self.get_config()
 335         if config is not None:
 336             for cname, cvaluelist in config.items():
 337                 for cv in cvaluelist:
 338                     outbuf += indent + '%s' %cname + ' %s\n' %cv
 339
 340         #outbuf += ('%s' %indent + '%s' %self.get_state_str() +
 341         #                ' %s' %self.get_status_str())
 342
 343         print outbuf
 344
 345
 346     def dump_json(self, logger):
 347         json.dumps(self)