pkg/iface.py

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