]>
Commit | Line | Data |
---|---|---|
1 | #!/usr/bin/python | |
2 | # | |
3 | # Copyright 2013. Cumulus Networks, Inc. | |
4 | # Author: Roopa Prabhu, roopa@cumulusnetworks.com | |
5 | # | |
6 | # ifaceScheduler -- | |
7 | # interface scheduler | |
8 | # | |
9 | ||
10 | from statemanager import * | |
11 | from iface import * | |
12 | from graph import * | |
13 | from collections import deque | |
14 | from collections import OrderedDict | |
15 | import logging | |
16 | import traceback | |
17 | import sys | |
18 | from graph import * | |
19 | from collections import deque | |
20 | from threading import * | |
21 | from ifupdownbase import * | |
22 | ||
23 | class ifaceSchedulerFlags(): | |
24 | INORDER = 0x1 | |
25 | POSTORDER = 0x2 | |
26 | ||
27 | class ifaceScheduler(): | |
28 | """ scheduler functions to schedule configuration of interfaces. | |
29 | ||
30 | supports scheduling of interfaces serially in plain interface list | |
31 | or dependency graph format. | |
32 | """ | |
33 | ||
34 | _STATE_CHECK = True | |
35 | ||
36 | token_pool = None | |
37 | ||
38 | @classmethod | |
39 | def run_iface_op(cls, ifupdownobj, ifaceobj, op, cenv): | |
40 | """ Runs sub operation on an interface """ | |
41 | ifacename = ifaceobj.name | |
42 | ||
43 | if (cls._STATE_CHECK and | |
44 | (ifaceobj.state >= ifaceState.from_str(op)) and | |
45 | (ifaceobj.status == ifaceStatus.SUCCESS)): | |
46 | ifupdownobj.logger.debug('%s: already in state %s' %(ifacename, op)) | |
47 | return | |
48 | ||
49 | # first run ifupdownobj handlers | |
50 | handler = ifupdownobj.ops_handlers.get(op) | |
51 | if handler: | |
52 | if not ifaceobj.addr_method or (ifaceobj.addr_method and | |
53 | ifaceobj.addr_method != 'manual'): | |
54 | handler(ifupdownobj, ifaceobj) | |
55 | ||
56 | if not ifupdownobj.ADDONS_ENABLE: return | |
57 | ||
58 | for mname in ifupdownobj.module_ops.get(op): | |
59 | m = ifupdownobj.modules.get(mname) | |
60 | err = 0 | |
61 | try: | |
62 | if hasattr(m, 'run'): | |
63 | msg = ('%s: %s : running module %s' %(ifacename, op, mname)) | |
64 | if op == 'query-checkcurr': | |
65 | # Dont check curr if the interface object was | |
66 | # auto generated | |
67 | if (ifaceobj.priv_flags & ifupdownobj.NOCONFIG): | |
68 | continue | |
69 | ifupdownobj.logger.debug(msg) | |
70 | m.run(ifaceobj, op, | |
71 | query_ifaceobj=ifupdownobj.create_n_save_ifaceobjcurr(ifaceobj)) | |
72 | else: | |
73 | ifupdownobj.logger.debug(msg) | |
74 | m.run(ifaceobj, op) | |
75 | except Exception, e: | |
76 | err = 1 | |
77 | ifupdownobj.log_error(str(e)) | |
78 | finally: | |
79 | if err: | |
80 | ifaceobj.set_state_n_status(ifaceState.from_str(op), | |
81 | ifaceStatus.ERROR) | |
82 | else: | |
83 | ifaceobj.set_state_n_status(ifaceState.from_str(op), | |
84 | ifaceStatus.SUCCESS) | |
85 | ||
86 | if ifupdownobj.COMPAT_EXEC_SCRIPTS: | |
87 | # execute /etc/network/ scripts | |
88 | for mname in ifupdownobj.script_ops.get(op, []): | |
89 | ifupdownobj.logger.debug('%s: %s : running script %s' | |
90 | %(ifacename, op, mname)) | |
91 | try: | |
92 | ifupdownobj.exec_command(mname, cmdenv=cenv) | |
93 | except Exception, e: | |
94 | ifupdownobj.log_error(str(e)) | |
95 | ||
96 | @classmethod | |
97 | def run_iface_ops(cls, ifupdownobj, ifaceobj, ops): | |
98 | """ Runs all operations on an interface """ | |
99 | ifacename = ifaceobj.name | |
100 | # minor optimization. If operation is 'down', proceed only | |
101 | # if interface exists in the system | |
102 | if 'down' in ops[0] and not ifupdownobj.link_exists(ifacename): | |
103 | ifupdownobj.logger.debug('%s: does not exist' %ifacename) | |
104 | return | |
105 | cenv=None | |
106 | if ifupdownobj.COMPAT_EXEC_SCRIPTS: | |
107 | # For backward compatibility generate env variables | |
108 | # for attributes | |
109 | cenv = ifupdownobj.generate_running_env(ifaceobj, ops[0]) | |
110 | map(lambda op: cls.run_iface_op(ifupdownobj, ifaceobj, op, cenv), ops) | |
111 | posthookfunc = ifupdownobj.sched_hooks.get('posthook') | |
112 | if posthookfunc: | |
113 | posthookfunc(ifupdownobj, ifaceobj, ops[0]) | |
114 | ||
115 | @classmethod | |
116 | def _check_upperifaces(cls, ifupdownobj, ifaceobj, ops, parent, | |
117 | followdependents=False): | |
118 | """ Check if conflicting upper ifaces are around and warn if required | |
119 | ||
120 | Returns False if this interface needs to be skipped, | |
121 | else return True """ | |
122 | ||
123 | # XXX: simply return for now, the warnings this function prints | |
124 | # are very confusing. Get rid of this function soon | |
125 | return True | |
126 | ||
127 | if 'up' in ops[0] and followdependents: | |
128 | return True | |
129 | ||
130 | # Deal with upperdevs first | |
131 | ulist = ifaceobj.upperifaces | |
132 | if ulist: | |
133 | tmpulist = ([u for u in ulist if u != parent] if parent | |
134 | else ulist) | |
135 | if not tmpulist: | |
136 | return True | |
137 | if 'down' in ops[0]: | |
138 | # XXX: This is expensive. Find a cheaper way to do this | |
139 | # if any of the upperdevs are present, | |
140 | # dont down this interface | |
141 | for u in tmpulist: | |
142 | if ifupdownobj.link_exists(u): | |
143 | if not ifupdownobj.FORCE and not ifupdownobj.ALL: | |
144 | ifupdownobj.logger.warn('%s: ' %ifaceobj.name + | |
145 | 'upperiface %s still around' %u) | |
146 | return True | |
147 | elif 'up' in ops[0] and not ifupdownobj.ALL: | |
148 | # For 'up', just warn that there is an upperdev which is | |
149 | # probably not up | |
150 | for u in tmpulist: | |
151 | if not ifupdownobj.link_exists(u): | |
152 | ifupdownobj.logger.warn('%s: ' %ifaceobj.name + | |
153 | 'upper iface %s does not exist' %u) | |
154 | return True | |
155 | ||
156 | @classmethod | |
157 | def run_iface_graph(cls, ifupdownobj, ifacename, ops, parent=None, | |
158 | order=ifaceSchedulerFlags.POSTORDER, | |
159 | followdependents=True): | |
160 | """ runs interface by traversing all nodes rooted at itself """ | |
161 | ||
162 | # Each ifacename can have a list of iface objects | |
163 | ifaceobjs = ifupdownobj.get_ifaceobjs(ifacename) | |
164 | if not ifaceobjs: | |
165 | raise Exception('%s: not found' %ifacename) | |
166 | ||
167 | for ifaceobj in ifaceobjs: | |
168 | if not cls._check_upperifaces(ifupdownobj, ifaceobj, | |
169 | ops, parent, followdependents): | |
170 | return | |
171 | if order == ifaceSchedulerFlags.INORDER: | |
172 | # If inorder, run the iface first and then its dependents | |
173 | cls.run_iface_ops(ifupdownobj, ifaceobj, ops) | |
174 | ||
175 | # Run lowerifaces or dependents | |
176 | dlist = ifaceobj.lowerifaces | |
177 | if dlist: | |
178 | ifupdownobj.logger.debug('%s: found dependents %s' | |
179 | %(ifacename, str(dlist))) | |
180 | try: | |
181 | if not followdependents: | |
182 | # XXX: this is yet another extra step, | |
183 | # but is needed for interfaces that are | |
184 | # implicit dependents. even though we are asked to | |
185 | # not follow dependents, we must follow the ones | |
186 | # that dont have user given config. Because we own them | |
187 | new_dlist = [d for d in dlist | |
188 | if ifupdownobj.is_iface_noconfig(d)] | |
189 | if new_dlist: | |
190 | cls.run_iface_list(ifupdownobj, new_dlist, ops, | |
191 | ifacename, order, | |
192 | followdependents, | |
193 | continueonfailure=False) | |
194 | else: | |
195 | cls.run_iface_list(ifupdownobj, dlist, ops, | |
196 | ifacename, order, | |
197 | followdependents, | |
198 | continueonfailure=False) | |
199 | except Exception, e: | |
200 | if (ifupdownobj.ignore_error(str(e))): | |
201 | pass | |
202 | else: | |
203 | # Dont bring the iface up if children did not come up | |
204 | ifaceobj.set_state_n_status(ifaceState.NEW, | |
205 | ifaceStatus.ERROR) | |
206 | raise | |
207 | if order == ifaceSchedulerFlags.POSTORDER: | |
208 | cls.run_iface_ops(ifupdownobj, ifaceobj, ops) | |
209 | ||
210 | @classmethod | |
211 | def run_iface_list(cls, ifupdownobj, ifacenames, | |
212 | ops, parent=None, order=ifaceSchedulerFlags.POSTORDER, | |
213 | followdependents=True, continueonfailure=True): | |
214 | """ Runs interface list """ | |
215 | ||
216 | for ifacename in ifacenames: | |
217 | try: | |
218 | cls.run_iface_graph(ifupdownobj, ifacename, ops, parent, | |
219 | order, followdependents) | |
220 | except Exception, e: | |
221 | if continueonfailure: | |
222 | if ifupdownobj.logger.isEnabledFor(logging.DEBUG): | |
223 | traceback.print_tb(sys.exc_info()[2]) | |
224 | ifupdownobj.logger.error('%s : %s' %(ifacename, str(e))) | |
225 | pass | |
226 | else: | |
227 | if (ifupdownobj.ignore_error(str(e))): | |
228 | pass | |
229 | else: | |
230 | raise Exception('%s : (%s)' %(ifacename, str(e))) | |
231 | ||
232 | @classmethod | |
233 | def run_iface_graph_upper(cls, ifupdownobj, ifacename, ops, parent=None, | |
234 | followdependents=True, skip_root=False): | |
235 | """ runs interface by traversing all nodes rooted at itself """ | |
236 | ||
237 | # Each ifacename can have a list of iface objects | |
238 | ifaceobjs = ifupdownobj.get_ifaceobjs(ifacename) | |
239 | if not ifaceobjs: | |
240 | raise Exception('%s: not found' %ifacename) | |
241 | ||
242 | for ifaceobj in ifaceobjs: | |
243 | if not skip_root: | |
244 | # run the iface first and then its upperifaces | |
245 | cls.run_iface_ops(ifupdownobj, ifaceobj, ops) | |
246 | ||
247 | # Run upperifaces | |
248 | ulist = ifaceobj.upperifaces | |
249 | if ulist: | |
250 | ifupdownobj.logger.debug('%s: found upperifaces %s' | |
251 | %(ifacename, str(ulist))) | |
252 | try: | |
253 | cls.run_iface_list_upper(ifupdownobj, ulist, ops, | |
254 | ifacename, | |
255 | followdependents, | |
256 | continueonfailure=True) | |
257 | except Exception, e: | |
258 | if (ifupdownobj.ignore_error(str(e))): | |
259 | pass | |
260 | else: | |
261 | raise | |
262 | ||
263 | @classmethod | |
264 | def run_iface_list_upper(cls, ifupdownobj, ifacenames, | |
265 | ops, parent=None, followdependents=True, | |
266 | continueonfailure=True, skip_root=False): | |
267 | """ Runs interface list """ | |
268 | ||
269 | for ifacename in ifacenames: | |
270 | try: | |
271 | cls.run_iface_graph_upper(ifupdownobj, ifacename, ops, parent, | |
272 | followdependents, skip_root) | |
273 | except Exception, e: | |
274 | if continueonfailure: | |
275 | if ifupdownobj.logger.isEnabledFor(logging.DEBUG): | |
276 | traceback.print_tb(sys.exc_info()[2]) | |
277 | ifupdownobj.logger.error('%s : %s' %(ifacename, str(e))) | |
278 | pass | |
279 | else: | |
280 | if (ifupdownobj.ignore_error(str(e))): | |
281 | pass | |
282 | else: | |
283 | raise Exception('%s : (%s)' %(ifacename, str(e))) | |
284 | ||
285 | @classmethod | |
286 | def sched_ifaces(cls, ifupdownobj, ifacenames, ops, | |
287 | dependency_graph=None, indegrees=None, | |
288 | order=ifaceSchedulerFlags.POSTORDER, | |
289 | followdependents=True): | |
290 | """ Runs iface dependeny graph by visiting all the nodes | |
291 | ||
292 | Parameters: | |
293 | ----------- | |
294 | ifupdownobj : ifupdown object (used for getting and updating iface | |
295 | object state) | |
296 | dependency_graph : dependency graph in adjacency list | |
297 | format (contains more than one dependency graph) | |
298 | ops : list of operations to perform eg ['pre-up', 'up', 'post-up'] | |
299 | ||
300 | indegrees : indegree array if present is used to determine roots | |
301 | of the graphs in the dependency_graph | |
302 | """ | |
303 | ||
304 | if not ifupdownobj.ALL or not followdependents or len(ifacenames) == 1: | |
305 | # If there is any interface that does exist, maybe it is a | |
306 | # logical interface and we have to followupperifaces | |
307 | followupperifaces = (True if | |
308 | [i for i in ifacenames | |
309 | if not ifupdownobj.link_exists(i)] | |
310 | else False) | |
311 | cls.run_iface_list(ifupdownobj, ifacenames, ops, | |
312 | parent=None,order=order, | |
313 | followdependents=followdependents) | |
314 | if (not ifupdownobj.ALL and | |
315 | (followdependents or followupperifaces) and 'up' in ops[0]): | |
316 | # If user had given a set of interfaces to bring up | |
317 | # try and execute 'up' on the upperifaces | |
318 | ifupdownobj.logger.info('running upperifaces if available') | |
319 | cls._STATE_CHECK = False | |
320 | cls.run_iface_list_upper(ifupdownobj, ifacenames, ops, | |
321 | skip_root=True) | |
322 | cls._STATE_CHECK = True | |
323 | return | |
324 | run_queue = [] | |
325 | ||
326 | # Get a sorted list of all interfaces | |
327 | if not indegrees: | |
328 | indegrees = OrderedDict() | |
329 | for ifacename in dependency_graph.keys(): | |
330 | indegrees[ifacename] = ifupdownobj.get_iface_refcnt(ifacename) | |
331 | sorted_ifacenames = graph.topological_sort_graphs_all(dependency_graph, | |
332 | dict(indegrees)) | |
333 | ifupdownobj.logger.debug('sorted ifacenames %s : ' | |
334 | %str(sorted_ifacenames)) | |
335 | ||
336 | # From the sorted list, pick interfaces that user asked | |
337 | # and those that dont have any dependents first | |
338 | [run_queue.append(ifacename) | |
339 | for ifacename in sorted_ifacenames | |
340 | if ifacename in ifacenames and | |
341 | not indegrees.get(ifacename)] | |
342 | ||
343 | ifupdownobj.logger.debug('graph roots (interfaces that dont have ' | |
344 | 'dependents):' + ' %s' %str(run_queue)) | |
345 | cls.run_iface_list(ifupdownobj, run_queue, ops, | |
346 | parent=None,order=order, | |
347 | followdependents=followdependents) |