]>
Commit | Line | Data |
---|---|---|
a6f80f0e | 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 |