Merge lp:~chipaca/ubuntuone-client/really-fix-duplicate-connections into lp:ubuntuone-client
- really-fix-duplicate-connections
- Merge into trunk
Proposed by
John Lenton
Status: | Merged | ||||
---|---|---|---|---|---|
Approved by: | Eric Casteleijn | ||||
Approved revision: | 220 | ||||
Merged at revision: | not available | ||||
Proposed branch: | lp:~chipaca/ubuntuone-client/really-fix-duplicate-connections | ||||
Merge into: | lp:ubuntuone-client | ||||
Diff against target: |
2596 lines 6 files modified
contrib/ck_states.py (+0/-142) tests/syncdaemon/test_main.py (+4/-1) tests/syncdaemon/test_states.py (+571/-0) ubuntuone/syncdaemon/action_queue.py (+11/-0) ubuntuone/syncdaemon/state.py (+0/-1) ubuntuone/syncdaemon/states.py (+461/-1113) |
||||
To merge this branch: | bzr merge lp:~chipaca/ubuntuone-client/really-fix-duplicate-connections | ||||
Related bugs: |
|
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
Eric Casteleijn (community) | Approve | ||
Rick McBride (community) | Approve | ||
Review via email: mp+12970@code.launchpad.net |
Commit message
fixes #420354 (BadTransitions happening due to there being multiple active connections on the client)
Description of the change
To post a comment you must log in.
Revision history for this message
John Lenton (chipaca) wrote : | # |
Revision history for this message
Rick McBride (rmcbride) wrote : | # |
LOoks good! very long but it makes sense and tests pass.
review:
Approve
Revision history for this message
Eric Casteleijn (thisfred) wrote : | # |
Wow, that's a truly Homeric branch. I have browsed through it all, and see nothing obviously wrong and a lot of things obviously right. Also the Kabillion tests all pass!
review:
Approve
Revision history for this message
John Lenton (chipaca) wrote : | # |
On Wed, Oct 07, 2009 at 02:32:19PM -0000, Eric Casteleijn wrote:
> Wow, that's a truly Homeric branch.
which Homer would that be? It makes a difference :)
Revision history for this message
Eric Casteleijn (thisfred) wrote : | # |
> On Wed, Oct 07, 2009 at 02:32:19PM -0000, Eric Casteleijn wrote:
> > Wow, that's a truly Homeric branch.
>
> which Homer would that be? It makes a difference :)
Doh! I meant the rather verbose one! ;)
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1 | === removed file 'contrib/ck_states.py' |
2 | --- contrib/ck_states.py 2009-08-12 19:05:14 +0000 |
3 | +++ contrib/ck_states.py 1970-01-01 00:00:00 +0000 |
4 | @@ -1,142 +0,0 @@ |
5 | -""" |
6 | -This is a sanity checker for the humongous ball of dragonspit that is |
7 | -ubuntuone.syncdaemon.states |
8 | -""" |
9 | - |
10 | -import re |
11 | - |
12 | -from ubuntuone.syncdaemon import states, event_queue |
13 | - |
14 | - |
15 | -all_states = dict((k, v) for (k, v) in vars(states).items() |
16 | - if isinstance(v, states.SyncDaemonState)) |
17 | - |
18 | -is_start = re.compile(r'(?:^START_|_START(?:_WITH_[^_]+Q)?$)').search |
19 | -has_q = re.compile(r'_WITH_([^_]+)Q$|^(?:START_)?WORKING_ON_(....)').search |
20 | - |
21 | -all_trns = set(sum((state.transitions.values() |
22 | - for state in all_states.values()), [])) |
23 | - |
24 | -for name, state in sorted(all_states.items()): |
25 | - if name != state.name: |
26 | - # the name of the object and the object's name attribute |
27 | - # should be the same |
28 | - print name, 'says it is called', state.name |
29 | - |
30 | - if isinstance(state, states.WorkingSDState): |
31 | - if state.with_q is None and has_q(name): |
32 | - # WorkingSDState instances that have a name such as |
33 | - # FOO_WITH_METAQ should be initialized with with_q='META' |
34 | - print name, 'should have with_q!' |
35 | - elif state.with_q and not name.endswith(state.with_q): |
36 | - print name, 'says it is with_q', state.with_q |
37 | - |
38 | - # check the state is 'reachable' |
39 | - if name not in all_trns: |
40 | - print name, 'is not the target of any transition!' |
41 | - |
42 | - # check the events and final states mentioned in the transitions |
43 | - # all exist |
44 | - for evt, trn in sorted(state.transitions.items()): |
45 | - if evt not in event_queue.EVENTS: |
46 | - print '%s responds to %s event which 404' % (name, trn) |
47 | - if trn not in all_states: |
48 | - print '%s --[%s]--> %s which 404' % (name, evt, trn) |
49 | - |
50 | - if is_start(name): |
51 | - # checks specific to START states |
52 | - if state.enter is None: |
53 | - # a START state with no enter is not a START state at all |
54 | - print name, 'has no enter' |
55 | - other_name = re.sub(r'_START|START_', '', name) |
56 | - if other_name not in all_states: |
57 | - # a START state with no homonymous non-START state? |
58 | - if not name.startswith('START_CONNECTED_CLEANUP'): |
59 | - print name, 'has no non-starter' |
60 | - else: |
61 | - # a START state and its homonymous non-START state should |
62 | - # handle pretty much the same events, and react in similar |
63 | - # ways |
64 | - other = all_states[other_name] |
65 | - this_trn = set(state.transitions) |
66 | - other_trn = set(other.transitions) |
67 | - only_in_this = this_trn - other_trn |
68 | - only_in_other = other_trn - this_trn \ |
69 | - - set(['SYS_SERVER_RESCAN_DONE', 'SYS_CLEANUP_FINISHED']) |
70 | - if only_in_this: |
71 | - # an event in the START state is not handled by the non-START |
72 | - print 'missing from %s: %s' % (other_name, |
73 | - ", ".join(sorted(only_in_this))) |
74 | - if only_in_other: |
75 | - # viceversa |
76 | - print 'missing from %s: %s' % (name, |
77 | - ", ".join(sorted(only_in_other))) |
78 | - for trn in sorted(this_trn.intersection(other_trn)): |
79 | - if state.transitions[trn] != other.transitions[trn]: |
80 | - # the is handled, but differently |
81 | - if not (name == state.transitions[trn] |
82 | - and other.name == other.transitions[trn]): |
83 | - print '%s pushes %s --> %s, but %s --> %s' % \ |
84 | - (trn, name, state.transitions[trn], |
85 | - other.name, other.transitions[trn]) |
86 | - else: |
87 | - if state.enter is not None: |
88 | - # a non-START state with an enter is actually a START state |
89 | - print name, 'has enter' |
90 | - |
91 | - # most states that have a _WITH_<some>Q should have all three |
92 | - has_withq = any((name + '_WITH_' + queue in all_states) |
93 | - for queue in ('METAQ', 'CONTQ', 'BOTHQ')) |
94 | - if has_withq: |
95 | - for queue in ('METAQ', 'CONTQ', 'BOTHQ'): |
96 | - other_name = name + '_WITH_' + queue |
97 | - if other_name not in all_states: |
98 | - print name, 'has some queues but not', queue |
99 | - else: |
100 | - other = all_states[other_name] |
101 | - this_trn = set(state.transitions) |
102 | - other_trn = set(other.transitions) |
103 | - if this_trn != other_trn: |
104 | - only_in_this = this_trn - other_trn |
105 | - only_in_other = other_trn - this_trn |
106 | - if only_in_this: |
107 | - print 'missing from %s: %s' % \ |
108 | - (other_name, ", ".join(sorted(only_in_this))) |
109 | - if only_in_other: |
110 | - print 'missing from %s: %s' % \ |
111 | - (name, ", ".join(sorted(only_in_other))) |
112 | - # the tuple is SYS_META_QUEUE_WAITING, _DONE, and then _CONTENT_ |
113 | - ok_trns = {'meta': ('meta', '', 'both', 'meta'), |
114 | - 'cont': ('both', 'cont', 'cont', ''), |
115 | - 'both': ('both', 'cont', 'both', 'meta'), |
116 | - '': ('meta', '', 'cont', ''), |
117 | - } |
118 | - if has_q(state.name): |
119 | - this_q = filter(None, has_q(state.name).groups())[0].lower() |
120 | - else: |
121 | - this_q = '' |
122 | - for i, evt in enumerate(['SYS_META_QUEUE_WAITING', |
123 | - 'SYS_META_QUEUE_DONE', |
124 | - 'SYS_CONTENT_QUEUE_WAITING', |
125 | - 'SYS_CONTENT_QUEUE_DONE']): |
126 | - trn = state.transitions.get(evt, None) |
127 | - if trn is None: |
128 | - continue |
129 | - if has_q(trn): |
130 | - that_q = filter(None, has_q(trn).groups())[0].lower() |
131 | - else: |
132 | - that_q = '' |
133 | - if ok_trns[this_q][i] != that_q: |
134 | - print '%s goes to %r on %r instead of %r' % (state.name, |
135 | - trn, evt, |
136 | - ok_trns[this_q][i]) |
137 | - |
138 | - # most states should handle the queue events |
139 | - if not (isinstance(state, states.AQErrorState) |
140 | - or name == 'INIT' |
141 | - or name.startswith('INIT_')): |
142 | - for event in ['SYS_META_QUEUE_WAITING', 'SYS_META_QUEUE_DONE', |
143 | - 'SYS_CONTENT_QUEUE_WAITING', 'SYS_CONTENT_QUEUE_DONE']: |
144 | - if event not in state.transitions: |
145 | - print name, 'does not handle', event |
146 | - |
147 | |
148 | === modified file 'tests/syncdaemon/test_main.py' |
149 | --- tests/syncdaemon/test_main.py 2009-09-01 20:35:36 +0000 |
150 | +++ tests/syncdaemon/test_main.py 2009-10-07 07:30:24 +0000 |
151 | @@ -118,6 +118,7 @@ |
152 | reactor.callLater(0, d0.callback, None) |
153 | |
154 | main = self.build_main(handshake_timeout=.5) |
155 | + main.action_q.connect = lambda *_: defer.Deferred() |
156 | main.event_q.subscribe(handler) |
157 | d = main.start() |
158 | d.addCallback(lambda _: main.event_q.push('SYS_NET_CONNECTED')) |
159 | @@ -154,11 +155,13 @@ |
160 | if the state is ok, pass the test |
161 | """ |
162 | if main.state.name != 'EXCESSIVE_TIMEOUTS': |
163 | - d0.errback(Exception('Too many timeouts')) |
164 | + d0.errback(Exception('Too many timeouts: %d' |
165 | + % cls.num_timeouts)) |
166 | else: |
167 | d0.callback('OK!') |
168 | |
169 | main = self.build_main(handshake_timeout=.1) |
170 | + main.action_q.connect = lambda *_: defer.Deferred() |
171 | main.event_q.subscribe(handler) |
172 | d = main.start() |
173 | d.addCallback(lambda _: main.event_q.push('SYS_NET_CONNECTED')) |
174 | |
175 | === added file 'tests/syncdaemon/test_states.py' |
176 | --- tests/syncdaemon/test_states.py 1970-01-01 00:00:00 +0000 |
177 | +++ tests/syncdaemon/test_states.py 2009-10-07 07:30:24 +0000 |
178 | @@ -0,0 +1,571 @@ |
179 | +""" |
180 | +Sanity checks for the humongous ball of dragonspit that is |
181 | +ubuntuone.syncdaemon.states |
182 | +""" |
183 | +import re |
184 | +import unittest |
185 | +from ubuntuone.syncdaemon import states, event_queue |
186 | + |
187 | + |
188 | +all_states = dict((k, v) for (k, v) in vars(states).items() |
189 | + if isinstance(v, states.SyncDaemonState)) |
190 | +all_trns = set(sum((state.transitions.values() |
191 | + for state in all_states.values()), [])) |
192 | + |
193 | +has_q = re.compile(r'.*_WITH_([^_]+Q)$').search |
194 | + |
195 | +class TestBasic(unittest.TestCase): |
196 | + """ |
197 | + Checks that apply to (nearly) all states |
198 | + """ |
199 | + def test_name(self): |
200 | + """ |
201 | + Check that the object's name is the same as the name of the object |
202 | + """ |
203 | + self.assertEqual(self.name, self.state.name) |
204 | + |
205 | + def _test_handle_external_events(self, external_event): |
206 | + """ |
207 | + Generic check, that the given external event is handled in some way |
208 | + """ |
209 | + self.assertTrue(external_event in self.state.transitions, |
210 | + "unhandled external event: %s" % external_event) |
211 | + |
212 | + def test_handle_sys_net_disconnected(self): |
213 | + """ |
214 | + Check SYS_NET_DISCONNECTED is handled |
215 | + """ |
216 | + self._test_handle_external_events('SYS_NET_DISCONNECTED') |
217 | + |
218 | + def test_handle_sys_net_connected(self): |
219 | + """ |
220 | + Check SYS_NET_CONNECTED is handled |
221 | + """ |
222 | + self._test_handle_external_events('SYS_NET_CONNECTED') |
223 | + |
224 | + def test_handle_sys_connect(self): |
225 | + """ |
226 | + Check SYS_CONNECT is handled |
227 | + """ |
228 | + self._test_handle_external_events('SYS_CONNECT') |
229 | + |
230 | + def test_handle_sys_disconnect(self): |
231 | + """ |
232 | + Check SYS_DISCONNECT is handled |
233 | + """ |
234 | + self._test_handle_external_events('SYS_DISCONNECT') |
235 | + |
236 | + def test_handle_sys_connection_lost(self): |
237 | + """ |
238 | + Check SYS_CONNECTION_LOST is handled |
239 | + """ |
240 | + self._test_handle_external_events('SYS_CONNECTION_LOST') |
241 | + |
242 | + def test_reachable(self): |
243 | + """ |
244 | + Check the state is reachable via a transition |
245 | + """ |
246 | + self.assertTrue(self.name in all_trns, |
247 | + "%s is not the target of any transition!" % self.name) |
248 | + |
249 | + def test_start_connecting(self): |
250 | + """ |
251 | + Check START_CONNECTING is only reached via SYS_CONNECTION_LOST |
252 | + or one of the READY states |
253 | + """ |
254 | + for evt, trn in self.state.transitions.items(): |
255 | + if ((trn.startswith('START_CONNECTING') |
256 | + and not (evt == 'SYS_CONNECTION_LOST' |
257 | + or 'WITH_CONNECTION_LOST' in self.name)) |
258 | + and not |
259 | + ((self.name.startswith('READY_WAITING') |
260 | + and evt == 'SYS_NET_CONNECTED') |
261 | + or (self.name.startswith('READY_WITH_NETWORK') |
262 | + and evt == 'SYS_CONNECT') |
263 | + or (self.name.startswith('READING_WAITING_WITH_NETWORK') |
264 | + and evt == 'SYS_LOCAL_RESCAN_DONE'))): |
265 | + raise AssertionError('%s --[%s]--> %s, not STANDOFFish' |
266 | + % (self.name, evt, trn)) |
267 | + |
268 | + def test_events_exist(self): |
269 | + """ |
270 | + Check the events are known to EventQueue |
271 | + """ |
272 | + diff = set(self.state.transitions) - set(event_queue.EVENTS) |
273 | + self.assertFalse(diff, "unknown events: %s" % ", ".join(diff)) |
274 | + |
275 | + def test_transitions_exist(self): |
276 | + """ |
277 | + Check the target states are known |
278 | + """ |
279 | + diff = set(self.state.transitions.values()) - set(all_states) |
280 | + self.assertFalse(diff, "unknown transitions: %s" % ", ".join(diff)) |
281 | + |
282 | + def test_enter_only_on_start(self): |
283 | + """ |
284 | + Only START_ states (and UNKNOWN_ERROR) should have an enter function |
285 | + """ |
286 | + if self.name != 'UNKNOWN_ERROR': |
287 | + if not self.name.startswith('START_'): |
288 | + if self.state.enter is not None: |
289 | + raise AssertionError("%s has enter" % self.name) |
290 | + |
291 | + def _test_withq_evt_ok(self, evt, exceptions): |
292 | + """ |
293 | + Generic check that the different WITH_xxxQ states are sane |
294 | + |
295 | + 'sane' here means that they follow the general pattern (seen |
296 | + in ok_trns), i.e. that the different queue events move the |
297 | + state correctly. There are exceptions, which can be specified. |
298 | + """ |
299 | + if evt not in self.state.transitions: |
300 | + return |
301 | + |
302 | + trn = self.state.transitions[evt] |
303 | + |
304 | + if has_q(self.name): |
305 | + this_q = filter(None, has_q(self.name).groups())[0].lower() |
306 | + else: |
307 | + this_q = '' |
308 | + |
309 | + ok_trns = {'metaq': {'SYS_CONTENT_QUEUE_DONE': 'metaq', |
310 | + 'SYS_CONTENT_QUEUE_WAITING': 'bothq', |
311 | + 'SYS_META_QUEUE_DONE': '', |
312 | + 'SYS_META_QUEUE_WAITING': 'metaq'}, |
313 | + 'contq': {'SYS_CONTENT_QUEUE_DONE': '', |
314 | + 'SYS_CONTENT_QUEUE_WAITING': 'contq', |
315 | + 'SYS_META_QUEUE_DONE': 'contq', |
316 | + 'SYS_META_QUEUE_WAITING': 'bothq'}, |
317 | + 'bothq': {'SYS_CONTENT_QUEUE_DONE': 'metaq', |
318 | + 'SYS_CONTENT_QUEUE_WAITING': 'bothq', |
319 | + 'SYS_META_QUEUE_DONE': 'contq', |
320 | + 'SYS_META_QUEUE_WAITING': 'bothq'}, |
321 | + '': {'SYS_CONTENT_QUEUE_DONE': '', |
322 | + 'SYS_CONTENT_QUEUE_WAITING': 'contq', |
323 | + 'SYS_META_QUEUE_DONE': '', |
324 | + 'SYS_META_QUEUE_WAITING': 'metaq'}, |
325 | + } |
326 | + |
327 | + if has_q(trn): |
328 | + that_q = filter(None, has_q(trn).groups())[0].lower() |
329 | + else: |
330 | + that_q = '' |
331 | + if ok_trns[this_q][evt] != that_q: |
332 | + # a few exceptions exist |
333 | + if (self.name, trn) not in exceptions: |
334 | + raise AssertionError('%s --[%s]--> %s instead of %s' |
335 | + % (self.name, evt, trn, |
336 | + ok_trns[this_q][evt])) |
337 | + def test_metaq_waiting_evt_ok(self): |
338 | + """ |
339 | + Check for correct handling of SYS_META_QUEUE_WAITING |
340 | + """ |
341 | + self._test_withq_evt_ok( |
342 | + 'SYS_META_QUEUE_WAITING', |
343 | + [('IDLE', 'START_WORKING_ON_METADATA'), |
344 | + ('START_WORKING_ON_BOTH', 'WORKING_ON_BOTH'), |
345 | + ('START_WORKING_ON_CONTENT', 'START_WORKING_ON_BOTH'), |
346 | + ('START_WORKING_ON_METADATA_WITH_CONTQ', |
347 | + 'WORKING_ON_METADATA_WITH_CONTQ'), |
348 | + ('START_WORKING_ON_METADATA', 'WORKING_ON_METADATA'), |
349 | + ('WORKING_ON_BOTH', 'WORKING_ON_BOTH'), |
350 | + ('WORKING_ON_CONTENT', 'START_WORKING_ON_BOTH'), |
351 | + ('WORKING_ON_METADATA_WITH_CONTQ', |
352 | + 'WORKING_ON_METADATA_WITH_CONTQ'), |
353 | + ('WORKING_ON_METADATA', 'WORKING_ON_METADATA'), |
354 | + ]) |
355 | + |
356 | + def test_metaq_done_evt_ok(self): |
357 | + """ |
358 | + Check for correct handling of SYS_META_QUEUE_DONE |
359 | + """ |
360 | + self._test_withq_evt_ok( |
361 | + 'SYS_META_QUEUE_DONE', |
362 | + [('START_WORKING_ON_METADATA_WITH_CONTQ', |
363 | + 'START_WORKING_ON_CONTENT'), |
364 | + ('WORKING_ON_METADATA_WITH_CONTQ', 'START_WORKING_ON_CONTENT'), |
365 | + ]) |
366 | + |
367 | + def test_contq_waiting_ok(self): |
368 | + """ |
369 | + Check for correct handling of SYS_CONTENT_QUEUE_WAITING |
370 | + """ |
371 | + self._test_withq_evt_ok( |
372 | + 'SYS_CONTENT_QUEUE_WAITING', |
373 | + [('IDLE', 'START_WORKING_ON_CONTENT'), |
374 | + ('START_WORKING_ON_BOTH', 'WORKING_ON_BOTH'), |
375 | + ('START_WORKING_ON_CONTENT', 'WORKING_ON_CONTENT'), |
376 | + ('WORKING_ON_BOTH', 'WORKING_ON_BOTH'), |
377 | + ('WORKING_ON_CONTENT', 'WORKING_ON_CONTENT'), |
378 | + ]) |
379 | + |
380 | + def test_contq_done_ok(self): |
381 | + """ |
382 | + Check for correct handling of SYS_CONTENT_QUEUE_DONE |
383 | + """ |
384 | + self._test_withq_evt_ok('SYS_CONTENT_QUEUE_DONE', []) |
385 | + |
386 | + def test_non_network_transition_leaves_network_alone(self): |
387 | + """ |
388 | + Check that the non-network events affect the network state |
389 | + |
390 | + network events are SYS_NET_CONNECTED and SYS_NET_DISCONNECTED |
391 | + """ |
392 | + bad = [] |
393 | + tpl = "%s.has_network is %s but -[%s]->%s.has_network is %s" |
394 | + for evt, trn in self.state.transitions.items(): |
395 | + if evt in ('SYS_NET_CONNECTED', 'SYS_NET_DISCONNECTED'): |
396 | + continue |
397 | + trn = all_states[trn] |
398 | + if self.state.has_network != trn.has_network and not trn.is_error: |
399 | + bad.append(tpl % (self.state.name, |
400 | + self.state.has_network, |
401 | + evt, trn.name, |
402 | + trn.has_network)) |
403 | + self.assertFalse(bad, ";\n".join(bad)) |
404 | + |
405 | + def test_network_transition_changes_network_state(self): |
406 | + """ |
407 | + Check that network events affect the network state |
408 | + """ |
409 | + connected = self.state.transitions['SYS_NET_CONNECTED'] |
410 | + disconnected = self.state.transitions['SYS_NET_DISCONNECTED'] |
411 | + if not self.state.is_error: |
412 | + self.assertTrue(all_states[connected].has_network) |
413 | + else: |
414 | + self.assertFalse(all_states[connected].has_network) |
415 | + self.assertFalse(all_states[disconnected].has_network) |
416 | + |
417 | + def test_non_volitional_transition_leaves_volition_alone(self): |
418 | + """ |
419 | + Check that non-volitional events leave the volition alone |
420 | + |
421 | + Volitional events are SYS_CONNECT and SYS_DISCONNECT |
422 | + """ |
423 | + bad = [] |
424 | + tpl = "%s.wants_to_connect is %s but -[%s]->%s.wants_to_connect is %s" |
425 | + for evt, trn in self.state.transitions.items(): |
426 | + if evt in ('SYS_CONNECT', 'SYS_DISCONNECT'): |
427 | + continue |
428 | + trn = all_states[trn] |
429 | + if self.state.wants_to_connect != trn.wants_to_connect and not trn.is_error: |
430 | + bad.append(tpl % (self.state.name, |
431 | + self.state.wants_to_connect, |
432 | + evt, trn.name, |
433 | + trn.wants_to_connect)) |
434 | + self.assertFalse(bad, ";\n".join(bad)) |
435 | + |
436 | + |
437 | +class TestWithQ: |
438 | + """ |
439 | + Checks for states with a given with_q |
440 | + """ |
441 | + def get_thisq(self): |
442 | + """ |
443 | + Get the queue of the current state (from the state's name) |
444 | + """ |
445 | + m = has_q(self.state.name) |
446 | + if m is None: |
447 | + return None |
448 | + return filter(None, m.groups())[0] |
449 | + |
450 | + def test_withq(self): |
451 | + """ |
452 | + Test the queue specified via with_q and the state's name match |
453 | + """ |
454 | + if self.state.with_q is None and has_q(self.name): |
455 | + raise AssertionError('%s should have with_q %s, has None' |
456 | + % (self.name, self.get_thisq())) |
457 | + elif self.state.with_q != self.get_thisq(): |
458 | + raise AssertionError("%s's name imples with_q %s, has %s" |
459 | + % (self.name, self.get_thisq(), |
460 | + self.state.with_q)) |
461 | + |
462 | + def test_another_withq(self): |
463 | + """ |
464 | + Test that states with one of the with_q's have the others. |
465 | + |
466 | + Some exceptions exist. |
467 | + """ |
468 | + this_q = self.get_thisq() or '' |
469 | + is_ok = ((this_q == '' and self.state.with_q is None) |
470 | + or (this_q.upper() == self.state.with_q)) |
471 | + if not is_ok: |
472 | + if (self.name, this_q, self.state.with_q) not in [ |
473 | + ('START_WORKING_ON_CONTENT', 'cont', None), |
474 | + ('START_WORKING_ON_METADATA', 'meta', None), |
475 | + ('WORKING_ON_CONTENT', 'cont', None), |
476 | + ('WORKING_ON_METADATA', 'meta', None), |
477 | + ]: |
478 | + raise AssertionError( |
479 | + "%s's name implies %s, but attribute is %r" |
480 | + % (self.name, this_q or 'noQ', self.state.with_q)) |
481 | + |
482 | + |
483 | +class TestCleanupWithConnectionLost: |
484 | + """ |
485 | + Checks for CLEANUP states that have already seen SYS_CONNECTION_LOST |
486 | + """ |
487 | + def test_cleanup_with_connection_lost(self): |
488 | + """ |
489 | + CLEANUP_WITH_CONNECTION_LOST states have already gotten their |
490 | + CONNECTION_LOST, so they don't need to wait for it; they need |
491 | + to not wait for it, instead. |
492 | + """ |
493 | + if self.name.startswith('START_'): |
494 | + name = self.name[6:] |
495 | + else: |
496 | + name = self.name |
497 | + target = self.state.transitions['SYS_CONNECTION_LOST'] |
498 | + self.assertEqual(name, target) |
499 | + |
500 | +class TestCleanupPlain: |
501 | + """ |
502 | + Tests for CLEANUP states that have not yet seen SYS_CONNECTION_LOST |
503 | + """ |
504 | + def test_cleanup_plain_on_connection_lost(self): |
505 | + """ |
506 | + When the CONNECTION_LOST events come in, "plain" cleanup states |
507 | + need to go to the sibling CLEANUP_WITH_CONNECTION_LOST |
508 | + """ |
509 | + evt = 'SYS_CONNECTION_LOST' |
510 | + trn = self.state.transitions[evt] |
511 | + expected = self.name |
512 | + # start transitions don't transition to self |
513 | + expected = re.sub(r'^START_', '', expected) |
514 | + expected = re.sub(r'^CONNECTED_CLEANUP', |
515 | + 'CLEANUP_WITH_NETWORK', expected) |
516 | + expected = re.sub(r'(.*?)((?:_WITH_(?:CONT|META|BOTH)Q)?)$', |
517 | + r'\1_WITH_CONNECTION_LOST\2', |
518 | + expected) |
519 | + self.assertEqual(trn, expected, |
520 | + '%s --[%s]--> %s, should be %s' |
521 | + % (self.name, evt, trn, expected)) |
522 | + |
523 | +class TestCleanupNonStarter: |
524 | + """ |
525 | + Test for CLEANUP states that are not START_ states |
526 | + """ |
527 | + def test_cleanup_on_cleanup_done(self): |
528 | + """ |
529 | + Test non-START_ CLEANUP states handle SYS_CLEANUP_FINISHED |
530 | + appropriately |
531 | + """ |
532 | + self.assertTrue('SYS_CLEANUP_FINISHED' in self.state.transitions, |
533 | + '%s should handle SYS_CLEANUP_FINISHED' % self.name) |
534 | + evt = 'SYS_CLEANUP_FINISHED' |
535 | + trn = self.state.transitions[evt] |
536 | + self.assertTrue(trn.startswith('START_STANDOFF'), |
537 | + '%s --[%s]--> %s, should be START_STANDOFFish' |
538 | + % (self.name, evt, trn)) |
539 | + |
540 | +class TestStarter: |
541 | + """ |
542 | + Tests for START_ states |
543 | + """ |
544 | + def setUp(self): |
545 | + """ |
546 | + Common set-up code |
547 | + """ |
548 | + self.other_name = re.sub(r'^START_', '', self.name) |
549 | + self.other = all_states.get(self.other_name, None) |
550 | + if self.other is not None: |
551 | + self.this_trn = set(self.state.transitions) |
552 | + self.other_trn = set(self.other.transitions) |
553 | + self.only_in_this = self.this_trn - self.other_trn |
554 | + self.only_in_other = self.other_trn - self.this_trn \ |
555 | + - set(['SYS_SERVER_RESCAN_DONE', 'SYS_CLEANUP_FINISHED']) |
556 | + |
557 | + def test_starters_have_enter(self): |
558 | + """ |
559 | + All START_ states should have an enter function |
560 | + """ |
561 | + self.assertTrue(self.state.enter is not None, |
562 | + '%s should have an enter function' % self.name) |
563 | + |
564 | + def test_other_exists(self): |
565 | + """ |
566 | + All START_ states should have a non-START_ state |
567 | + """ |
568 | + self.assertTrue(self.other_name in all_states, |
569 | + '%s has no non-starter' % self.name) |
570 | + |
571 | + def test_no_events_only_in_this(self): |
572 | + """ |
573 | + All START_ states need to handle the same events as their |
574 | + non-START_ counterparts |
575 | + """ |
576 | + if self.other is None: |
577 | + raise AssertionError('missing non-starter, unable to test') |
578 | + self.assertFalse( |
579 | + self.only_in_this, |
580 | + # an event in the START state is not handled by the non-START |
581 | + 'missing from %s: %s' % (self.other_name, |
582 | + ", ".join(sorted(self.only_in_this)))) |
583 | + |
584 | + def test_no_events_only_in_other(self): |
585 | + """ |
586 | + in general, non-START_ states need to handle the same events |
587 | + as their START_ counterparts |
588 | + """ |
589 | + if self.other is None: |
590 | + raise AssertionError('missing non-starter, unable to test') |
591 | + self.assertFalse( |
592 | + self.only_in_other, |
593 | + 'missing from %s: %s' % (self.name, |
594 | + ", ".join(sorted(self.only_in_other)))) |
595 | + |
596 | + def test_same_transitions(self): |
597 | + """ |
598 | + in general, the transition dict for START_ and non-START_ |
599 | + states should be the same |
600 | + """ |
601 | + if self.other is None: |
602 | + raise AssertionError('missing non-starter, unable to test') |
603 | + bad = ['%s pushes %s --> %s, but %s --> %s' |
604 | + % (trn, self.name, self.state.transitions[trn], |
605 | + self.other.name, self.other.transitions[trn]) |
606 | + for trn in sorted(self.this_trn.intersection(self.other_trn)) |
607 | + if (self.state.transitions[trn] != self.other.transitions[trn] |
608 | + and not (self.name == self.state.transitions[trn] and |
609 | + self.other.name == self.other.transitions[trn]))] |
610 | + self.assertFalse(bad, bad) |
611 | + |
612 | + |
613 | +class TestOtherQ: |
614 | + """ |
615 | + Test for states that have _WITH_fooQ states |
616 | + """ |
617 | + def _test_other_queues(self, queue, exceptions): |
618 | + """ |
619 | + Check that a WITH_fooQ state exists for the given queue (with |
620 | + the given exceptions). Further, check that if it does indeed |
621 | + exist, it handles the same transitions. |
622 | + """ |
623 | + other_name = self.name + '_WITH_' + queue |
624 | + if other_name not in all_states: |
625 | + if self.name not in exceptions: |
626 | + raise AssertionError('%s has some queues but not %s' |
627 | + % (self.name, queue)) |
628 | + else: |
629 | + other = all_states[other_name] |
630 | + this_trn = set(self.state.transitions) |
631 | + other_trn = set(other.transitions) |
632 | + if this_trn != other_trn: |
633 | + only_in_this = this_trn - other_trn |
634 | + only_in_other = other_trn - this_trn |
635 | + if only_in_this: |
636 | + raise AssertionError('missing from %s: %s' % |
637 | + (other_name, |
638 | + ", ".join(sorted(only_in_this)))) |
639 | + if only_in_other: |
640 | + raise AssertionError('missing from %s: %s' % |
641 | + (self.name, |
642 | + ", ".join(sorted(only_in_other)))) |
643 | + |
644 | + def test_other_meta_queue(self): |
645 | + """ |
646 | + Check that a WITH_METAQ state exists for the current state |
647 | + (with exceptions). Further, check that if it does indeed |
648 | + exist, it handles the same transitions as the base state. |
649 | + """ |
650 | + self._test_other_queues('METAQ', [ |
651 | + 'START_CLEANUP_WAITING', |
652 | + 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
653 | + 'START_CONNECTED_CLEANUP', |
654 | + 'START_WORKING_ON_METADATA', |
655 | + 'WORKING_ON_METADATA', |
656 | + ]) |
657 | + |
658 | + def test_other_cont_queue(self): |
659 | + """ |
660 | + Check that a WITH_CONTQ state exists for the current state |
661 | + (with exceptions). Further, check that if it does indeed |
662 | + exist, it handles the same transitions as the base state. |
663 | + """ |
664 | + self._test_other_queues('CONTQ', []) |
665 | + |
666 | + def test_other_both_queue(self): |
667 | + """ |
668 | + Check that a WITH_BOTHQ state exists for the current state |
669 | + (with exceptions). Further, check that if it does indeed |
670 | + exist, it handles the same transitions as the base state. |
671 | + """ |
672 | + self._test_other_queues('BOTHQ', [ |
673 | + 'START_CLEANUP_WAITING', |
674 | + 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
675 | + 'START_CONNECTED_CLEANUP', |
676 | + 'START_WORKING_ON_METADATA', |
677 | + 'WORKING_ON_METADATA', |
678 | + ]) |
679 | + |
680 | + |
681 | +class TestHandleQueues: |
682 | + """ |
683 | + Tests for handling of queue events |
684 | + """ |
685 | + def _test_handles_queue_event(self, queue_event): |
686 | + """ |
687 | + Generic test that the current state handles the given queue event |
688 | + """ |
689 | + self.assertTrue(queue_event in self.state.transitions, |
690 | + self.name + ' does not handle ' + queue_event) |
691 | + |
692 | + def test_handles_meta_queue_waiting(self): |
693 | + """ |
694 | + Check SYS_META_QUEUE_WAITING is handled |
695 | + """ |
696 | + self._test_handles_queue_event('SYS_META_QUEUE_WAITING') |
697 | + |
698 | + def test_handles_content_queue_waiting(self): |
699 | + """ |
700 | + Check SYS_CONTENT_QUEUE_WAITING is handled |
701 | + """ |
702 | + self._test_handles_queue_event('SYS_CONTENT_QUEUE_WAITING') |
703 | + |
704 | + def test_handles_meta_queue_done(self): |
705 | + """ |
706 | + Check SYS_META_QUEUE_DONE is handled |
707 | + """ |
708 | + self._test_handles_queue_event('SYS_META_QUEUE_DONE') |
709 | + |
710 | + def test_handles_content_queue_done(self): |
711 | + """ |
712 | + Check SYS_CONTENT_QUEUE_DONE is handled |
713 | + """ |
714 | + self._test_handles_queue_event('SYS_CONTENT_QUEUE_DONE') |
715 | + |
716 | + |
717 | +def test_suite(): |
718 | + """ |
719 | + Build the test suite |
720 | + """ |
721 | + suite = unittest.TestSuite() |
722 | + loader = unittest.TestLoader() |
723 | + flag = object() |
724 | + for name, state in all_states.items(): |
725 | + bases = [TestBasic] |
726 | + if getattr(state, 'with_q', flag) is not flag: |
727 | + bases.append(TestWithQ) |
728 | + if re.search('CLEANUP.*WITH_CONNECTION_LOST', name): |
729 | + bases.append(TestCleanupWithConnectionLost) |
730 | + elif 'CLEANUP' in name: |
731 | + bases.append(TestCleanupPlain) |
732 | + if name.startswith('CLEANUP'): |
733 | + bases.append(TestCleanupNonStarter) |
734 | + if name.startswith('START_'): |
735 | + if not name.startswith('START_CONNECTED_CLEANUP'): |
736 | + # CONNECTED_CLEANUP doesn't exist; |
737 | + # we fake it with CLEANUP_WITH_NETWORK |
738 | + bases.append(TestStarter) |
739 | + if any((name + '_WITH_' + queue in all_states) |
740 | + for queue in ('METAQ', 'CONTQ', 'BOTHQ')): |
741 | + bases.append(TestOtherQ) |
742 | + if not (isinstance(state, states.AQErrorState) |
743 | + or name == 'INIT' |
744 | + or name.startswith('INIT_')): |
745 | + bases.append(TestHandleQueues) |
746 | + bases = tuple(reversed(bases)) |
747 | + test = type('Test_'+name, bases, {'name': name, 'state': state}) |
748 | + suite.addTest(loader.loadTestsFromTestCase(test)) |
749 | + return suite |
750 | |
751 | === modified file 'ubuntuone/syncdaemon/action_queue.py' |
752 | --- ubuntuone/syncdaemon/action_queue.py 2009-09-18 18:41:10 +0000 |
753 | +++ ubuntuone/syncdaemon/action_queue.py 2009-10-07 07:30:24 +0000 |
754 | @@ -183,12 +183,16 @@ |
755 | """ |
756 | connection_state = 'disconnected' |
757 | factory = None |
758 | + _finished = False |
759 | |
760 | def connectionMade(self): |
761 | """ |
762 | Called when a new connection is made. |
763 | All the state is saved in the factory. |
764 | """ |
765 | + if self._finished: |
766 | + # the factory is no longer interested in what we have to say |
767 | + return |
768 | logger.debug("connection made") |
769 | LoggingStorageClient.connectionMade(self) |
770 | self.connection_state = 'connected' |
771 | @@ -204,9 +208,13 @@ |
772 | """ |
773 | Close down the sockets |
774 | """ |
775 | + self._finished = True |
776 | logger.debug("disconnected") |
777 | if self.transport is not None: |
778 | self.transport.loseConnection() |
779 | + else: |
780 | + # fake the event |
781 | + self.factory.connectionLost(self, 'Transport is None') |
782 | |
783 | def connectionLost(self, reason=None): |
784 | """ |
785 | @@ -873,6 +881,9 @@ |
786 | if self.client is not None: |
787 | self.client.disconnect() |
788 | self.client = None |
789 | + else: |
790 | + # fake it |
791 | + self.connectionLost(None, 'client is None') |
792 | |
793 | def conectionFailed(self, reason=None): |
794 | """ |
795 | |
796 | === modified file 'ubuntuone/syncdaemon/state.py' |
797 | --- ubuntuone/syncdaemon/state.py 2009-08-28 20:46:35 +0000 |
798 | +++ ubuntuone/syncdaemon/state.py 2009-10-07 07:30:24 +0000 |
799 | @@ -95,7 +95,6 @@ |
800 | """ |
801 | self.watchdog = None |
802 | self.num_timeouts += 1 |
803 | - self.main.action_q.disconnect() |
804 | self.main.event_q.push('SYS_HANDSHAKE_TIMEOUT') |
805 | |
806 | @property |
807 | |
808 | === modified file 'ubuntuone/syncdaemon/states.py' |
809 | --- ubuntuone/syncdaemon/states.py 2009-08-13 14:49:48 +0000 |
810 | +++ ubuntuone/syncdaemon/states.py 2009-10-07 07:30:24 +0000 |
811 | @@ -19,6 +19,24 @@ |
812 | The states of the SyncDaemon |
813 | """ |
814 | |
815 | +from pprint import pformat |
816 | +from inspect import getsource |
817 | +from difflib import unified_diff |
818 | + |
819 | +def compare(this, that): |
820 | + this = vars(this) |
821 | + if this['enter'] is not None: |
822 | + this['enter'] = getsource(this['enter']).strip() |
823 | + that = vars(that) |
824 | + if that['enter'] is not None: |
825 | + that['enter'] = getsource(that['enter']).strip() |
826 | + if this != that: |
827 | + print "\n".join(unified_diff(pformat(this).split('\n'), |
828 | + pformat(that).split('\n'), |
829 | + 'new '+this['name'], 'old')) |
830 | + assert False |
831 | + |
832 | + |
833 | class BadTransition(Exception): |
834 | """ |
835 | An event arrived that the state didn't know how to handle. |
836 | @@ -50,6 +68,13 @@ |
837 | self.is_connected = is_connected |
838 | self.is_online = is_online |
839 | self.enter = enter |
840 | + self.has_network = any((self.is_connected, |
841 | + "WITH_NETWORK" in name, |
842 | + "CONNECTING" in name, |
843 | + "CONNECTED_CLEANUP" in name)) |
844 | + self.wants_to_connect = any((self.is_connected, |
845 | + "WAITING" in name, |
846 | + "CONNECTING" in name)) |
847 | self.is_handshake = 'SYS_HANDSHAKE_TIMEOUT' in other_transitions |
848 | self.transitions = dict(SYS_NET_CONNECTED=sys_net_connected_trn, |
849 | SYS_CONNECT=sys_connect_trn, |
850 | @@ -74,6 +99,81 @@ |
851 | raise BadTransition("State %s can't handle the %s event" |
852 | % (self.name, event)) |
853 | |
854 | + |
855 | + def clone_with_queue(self, qname, **extra_transitions): |
856 | + new_trns = self.transitions.copy() |
857 | + del new_trns['SYS_UNKNOWN_ERROR'] |
858 | + suffix = '_WITH_' + qname |
859 | + mqw_trn = new_trns.pop('SYS_META_QUEUE_WAITING') |
860 | + mqd_trn = new_trns.pop('SYS_META_QUEUE_DONE') |
861 | + cqw_trn = new_trns.pop('SYS_CONTENT_QUEUE_WAITING') |
862 | + cqd_trn = new_trns.pop('SYS_CONTENT_QUEUE_DONE') |
863 | + if self.name.startswith('START_'): |
864 | + bq_trn = self.name[6:] + '_WITH_BOTHQ' |
865 | + expected_name = 'START_' + dict(METAQ=mqw_trn, |
866 | + CONTQ=cqw_trn, BOTHQ=bq_trn)[qname] |
867 | + else: |
868 | + bq_trn = self.name + '_WITH_BOTHQ' |
869 | + expected_name = dict(METAQ=mqw_trn, |
870 | + CONTQ=cqw_trn, BOTHQ=bq_trn)[qname] |
871 | + mqw = dict(METAQ=mqw_trn, CONTQ=bq_trn, BOTHQ=bq_trn)[qname] |
872 | + mqd = dict(METAQ=mqd_trn, CONTQ=cqw_trn, BOTHQ=cqw_trn)[qname] |
873 | + cqw = dict(METAQ=bq_trn, CONTQ=cqw_trn, BOTHQ=bq_trn)[qname] |
874 | + cqd = dict(METAQ=mqw_trn, CONTQ=cqd_trn, BOTHQ=mqw_trn)[qname] |
875 | + new = SyncDaemonState(self.name + suffix, |
876 | + self.description + ', ' + qname + ' waiting', |
877 | + new_trns.pop('SYS_NET_CONNECTED') + suffix, |
878 | + new_trns.pop('SYS_CONNECT') + suffix, |
879 | + new_trns.pop('SYS_NET_DISCONNECTED') + suffix, |
880 | + new_trns.pop('SYS_DISCONNECT') + suffix, |
881 | + new_trns.pop('SYS_CONNECTION_LOST') + suffix, |
882 | + self.is_error, self.is_connected, self.is_online, |
883 | + self.enter, |
884 | + SYS_META_QUEUE_WAITING=mqw, |
885 | + SYS_META_QUEUE_DONE=mqd, |
886 | + SYS_CONTENT_QUEUE_WAITING=cqw, |
887 | + SYS_CONTENT_QUEUE_DONE=cqd) |
888 | + new.is_handshake = self.is_handshake |
889 | + new.with_q = qname |
890 | + assert new.name == expected_name, "%r != %r" % (new.name, expected_name) |
891 | + for evt, trn in new_trns.items(): |
892 | + if trn not in ['BAD_VERSION', 'CAPABILITIES_MISMATCH', 'AUTH_FAILED']: |
893 | + trn = trn + suffix |
894 | + new.transitions[evt] = trn |
895 | + for evt, trn in extra_transitions.items(): |
896 | + new.transitions[evt] = trn |
897 | + return new |
898 | + |
899 | + def clone_with_metaq(self, **extra_transitions): |
900 | + return self.clone_with_queue('METAQ', **extra_transitions) |
901 | + |
902 | + def clone_with_contq(self, **extra_transitions): |
903 | + return self.clone_with_queue('CONTQ', **extra_transitions) |
904 | + |
905 | + def clone_with_bothq(self, **extra_transitions): |
906 | + return self.clone_with_queue('BOTHQ', **extra_transitions) |
907 | + |
908 | + def clone_with_no_start(self, new_description, **extra_transitions): |
909 | + if not self.name.startswith('START_'): |
910 | + raise ValueError, "Not a START_ transition" |
911 | + name = self.name[6:] |
912 | + new_trns = self.transitions.copy() |
913 | + del new_trns['SYS_UNKNOWN_ERROR'] |
914 | + new_trns.update(extra_transitions) |
915 | + new = SyncDaemonState(name, |
916 | + new_description, |
917 | + new_trns.pop('SYS_NET_CONNECTED'), |
918 | + new_trns.pop('SYS_CONNECT'), |
919 | + new_trns.pop('SYS_NET_DISCONNECTED'), |
920 | + new_trns.pop('SYS_DISCONNECT'), |
921 | + new_trns.pop('SYS_CONNECTION_LOST'), |
922 | + self.is_error, self.is_connected, self.is_online, |
923 | + None, |
924 | + **new_trns) |
925 | + if getattr(self, 'with_q', object) is not object: |
926 | + new.with_q = self.with_q |
927 | + return new |
928 | + |
929 | class NonActiveConnectedSDState(SyncDaemonState): |
930 | """ |
931 | States that handle network disconnections with no cleanup |
932 | @@ -84,6 +184,7 @@ |
933 | ready_waiting = 'READY_WAITING' |
934 | ready_w_network = 'READY_WITH_NETWORK' |
935 | start_connecting = 'START_CONNECTING' |
936 | + self.with_q = with_q |
937 | if with_q is not None: |
938 | ready_waiting += '_WITH_' + with_q |
939 | ready_w_network += '_WITH_' + with_q |
940 | @@ -111,11 +212,15 @@ |
941 | suffix = '_WITH_' + with_q |
942 | else: |
943 | suffix = '' |
944 | + if name.startswith('START_'): |
945 | + next_name = name[6:] |
946 | + else: |
947 | + next_name = name |
948 | super(WorkingSDState, self).__init__( |
949 | - name, description, name, name, |
950 | + name, description, next_name, next_name, |
951 | 'START_CLEANUP_WAITING' + suffix, |
952 | 'START_CONNECTED_CLEANUP' + suffix, |
953 | - 'START_CLEANUP_WAITING_WITH_NETWORK' + suffix, |
954 | + 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST' + suffix, |
955 | is_connected=True, is_online=True, |
956 | **other_transitions) |
957 | |
958 | @@ -177,42 +282,9 @@ |
959 | SYS_CONTENT_QUEUE_WAITING='READING_WITH_CONTQ', |
960 | SYS_CONTENT_QUEUE_DONE='READING', |
961 | ) |
962 | - |
963 | -READING_WITH_METAQ = SyncDaemonState( |
964 | - 'READING_WITH_METAQ', |
965 | - 'doing local rescan, meta_q waiting', |
966 | - 'READING_WITH_NETWORK_WITH_METAQ', 'READING_WAITING_WITH_METAQ', |
967 | - 'READING_WITH_METAQ', 'READING_WITH_METAQ', 'READING_WITH_METAQ', |
968 | - SYS_LOCAL_RESCAN_DONE='READY_FOR_NETWORK_WITH_METAQ', |
969 | - SYS_META_QUEUE_WAITING='READING_WITH_METAQ', |
970 | - SYS_META_QUEUE_DONE='READING', |
971 | - SYS_CONTENT_QUEUE_WAITING='READING_WITH_BOTHQ', |
972 | - SYS_CONTENT_QUEUE_DONE='READING_WITH_METAQ', |
973 | - ) |
974 | - |
975 | -READING_WITH_CONTQ = SyncDaemonState( |
976 | - 'READING_WITH_CONTQ', |
977 | - 'doing local rescan, content_q waiting', |
978 | - 'READING_WITH_NETWORK_WITH_CONTQ', 'READING_WAITING_WITH_CONTQ', |
979 | - 'READING_WITH_CONTQ', 'READING_WITH_CONTQ', 'READING_WITH_CONTQ', |
980 | - SYS_LOCAL_RESCAN_DONE='READY_FOR_NETWORK_WITH_CONTQ', |
981 | - SYS_META_QUEUE_WAITING='READING_WITH_BOTHQ', |
982 | - SYS_META_QUEUE_DONE='READING_WITH_CONTQ', |
983 | - SYS_CONTENT_QUEUE_WAITING='READING_WITH_CONTQ', |
984 | - SYS_CONTENT_QUEUE_DONE='READING', |
985 | - ) |
986 | - |
987 | -READING_WITH_BOTHQ = SyncDaemonState( |
988 | - 'READING_WITH_BOTHQ', |
989 | - 'doing local rescan, both _q\'s waiting', |
990 | - 'READING_WITH_NETWORK_WITH_BOTHQ', 'READING_WAITING_WITH_BOTHQ', |
991 | - 'READING_WITH_BOTHQ', 'READING_WITH_BOTHQ', 'READING_WITH_BOTHQ', |
992 | - SYS_LOCAL_RESCAN_DONE='READY_FOR_NETWORK_WITH_BOTHQ', |
993 | - SYS_META_QUEUE_WAITING='READING_WITH_BOTHQ', |
994 | - SYS_META_QUEUE_DONE='READING_WITH_CONTQ', |
995 | - SYS_CONTENT_QUEUE_WAITING='READING_WITH_BOTHQ', |
996 | - SYS_CONTENT_QUEUE_DONE='READING_WITH_METAQ', |
997 | - ) |
998 | +READING_WITH_METAQ = READING.clone_with_metaq() |
999 | +READING_WITH_CONTQ = READING.clone_with_contq() |
1000 | +READING_WITH_BOTHQ = READING.clone_with_bothq() |
1001 | |
1002 | READING_WITH_NETWORK = SyncDaemonState( |
1003 | 'READING_WITH_NETWORK', |
1004 | @@ -225,48 +297,9 @@ |
1005 | SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_CONTQ', |
1006 | SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK', |
1007 | ) |
1008 | - |
1009 | -READING_WITH_NETWORK_WITH_METAQ = SyncDaemonState( |
1010 | - 'READING_WITH_NETWORK_WITH_METAQ', |
1011 | - 'doing local rescan; network is available, meta_q waiting', |
1012 | - 'READING_WITH_NETWORK_WITH_METAQ', |
1013 | - 'READING_WAITING_WITH_NETWORK_WITH_METAQ', |
1014 | - 'READING_WITH_METAQ', 'READING_WITH_NETWORK_WITH_METAQ', |
1015 | - 'READING_WITH_NETWORK_WITH_METAQ', |
1016 | - SYS_LOCAL_RESCAN_DONE='READY_WITH_NETWORK_WITH_METAQ', |
1017 | - SYS_META_QUEUE_WAITING='READING_WITH_NETWORK_WITH_METAQ', |
1018 | - SYS_META_QUEUE_DONE='READING_WITH_NETWORK', |
1019 | - SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ', |
1020 | - SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK_WITH_METAQ', |
1021 | - ) |
1022 | - |
1023 | -READING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState( |
1024 | - 'READING_WITH_NETWORK_WITH_CONTQ', |
1025 | - 'doing local rescan; network is available, content_q waiting', |
1026 | - 'READING_WITH_NETWORK_WITH_CONTQ', |
1027 | - 'READING_WAITING_WITH_NETWORK_WITH_CONTQ', |
1028 | - 'READING_WITH_CONTQ', 'READING_WITH_NETWORK_WITH_CONTQ', |
1029 | - 'READING_WITH_NETWORK_WITH_CONTQ', |
1030 | - SYS_LOCAL_RESCAN_DONE='READY_WITH_NETWORK_WITH_CONTQ', |
1031 | - SYS_META_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ', |
1032 | - SYS_META_QUEUE_DONE='READING_WITH_NETWORK_WITH_CONTQ', |
1033 | - SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_CONTQ', |
1034 | - SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK', |
1035 | - ) |
1036 | - |
1037 | -READING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState( |
1038 | - 'READING_WITH_NETWORK_WITH_BOTHQ', |
1039 | - 'doing local rescan; network is available, both _q\'s waiting', |
1040 | - 'READING_WITH_NETWORK_WITH_BOTHQ', |
1041 | - 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ', |
1042 | - 'READING_WITH_BOTHQ', 'READING_WITH_NETWORK_WITH_BOTHQ', |
1043 | - 'READING_WITH_NETWORK_WITH_BOTHQ', |
1044 | - SYS_LOCAL_RESCAN_DONE='READY_WITH_NETWORK_WITH_BOTHQ', |
1045 | - SYS_META_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ', |
1046 | - SYS_META_QUEUE_DONE='READING_WITH_NETWORK_WITH_CONTQ', |
1047 | - SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ', |
1048 | - SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK_WITH_METAQ', |
1049 | - ) |
1050 | +READING_WITH_NETWORK_WITH_METAQ = READING_WITH_NETWORK.clone_with_metaq() |
1051 | +READING_WITH_NETWORK_WITH_CONTQ = READING_WITH_NETWORK.clone_with_contq() |
1052 | +READING_WITH_NETWORK_WITH_BOTHQ = READING_WITH_NETWORK.clone_with_bothq() |
1053 | |
1054 | READING_WAITING = SyncDaemonState( |
1055 | 'READING_WAITING', |
1056 | @@ -279,49 +312,13 @@ |
1057 | SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_CONTQ', |
1058 | SYS_CONTENT_QUEUE_DONE='READING_WAITING', |
1059 | ) |
1060 | - |
1061 | -READING_WAITING_WITH_METAQ = SyncDaemonState( |
1062 | - 'READING_WAITING_WITH_METAQ', |
1063 | - 'doing local rescan; user wants to connect, meta_q waiting', |
1064 | - 'READING_WAITING_WITH_NETWORK_WITH_METAQ', 'READING_WAITING_WITH_METAQ', |
1065 | - 'READING_WAITING_WITH_METAQ', 'READING_WITH_METAQ', |
1066 | - 'READING_WAITING_WITH_METAQ', |
1067 | - SYS_LOCAL_RESCAN_DONE='READY_WAITING_WITH_METAQ', |
1068 | - SYS_META_QUEUE_WAITING='READING_WAITING_WITH_METAQ', |
1069 | - SYS_META_QUEUE_DONE='READING_WAITING', |
1070 | - SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ', |
1071 | - SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_METAQ', |
1072 | - ) |
1073 | - |
1074 | -READING_WAITING_WITH_CONTQ = SyncDaemonState( |
1075 | - 'READING_WAITING_WITH_CONTQ', |
1076 | - 'doing local rescan; user wants to connect, content_q waiting', |
1077 | - 'READING_WAITING_WITH_NETWORK_WITH_CONTQ', 'READING_WAITING_WITH_CONTQ', |
1078 | - 'READING_WAITING_WITH_CONTQ', 'READING_WITH_CONTQ', |
1079 | - 'READING_WAITING_WITH_CONTQ', |
1080 | - SYS_LOCAL_RESCAN_DONE='READY_WAITING_WITH_CONTQ', |
1081 | - SYS_META_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ', |
1082 | - SYS_META_QUEUE_DONE='READING_WAITING_WITH_CONTQ', |
1083 | - SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_CONTQ', |
1084 | - SYS_CONTENT_QUEUE_DONE='READING_WAITING', |
1085 | - ) |
1086 | - |
1087 | -READING_WAITING_WITH_BOTHQ = SyncDaemonState( |
1088 | - 'READING_WAITING_WITH_BOTHQ', |
1089 | - 'doing local rescan; user wants to connect, both _q\'s waiting', |
1090 | - 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ', 'READING_WAITING_WITH_BOTHQ', |
1091 | - 'READING_WAITING_WITH_BOTHQ', 'READING_WITH_BOTHQ', |
1092 | - 'READING_WAITING_WITH_BOTHQ', |
1093 | - SYS_LOCAL_RESCAN_DONE='READY_WAITING_WITH_BOTHQ', |
1094 | - SYS_META_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ', |
1095 | - SYS_META_QUEUE_DONE='READING_WAITING_WITH_CONTQ', |
1096 | - SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ', |
1097 | - SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_METAQ', |
1098 | - ) |
1099 | +READING_WAITING_WITH_METAQ = READING_WAITING.clone_with_metaq() |
1100 | +READING_WAITING_WITH_CONTQ = READING_WAITING.clone_with_contq() |
1101 | +READING_WAITING_WITH_BOTHQ = READING_WAITING.clone_with_bothq() |
1102 | |
1103 | READING_WAITING_WITH_NETWORK = SyncDaemonState( |
1104 | 'READING_WAITING_WITH_NETWORK', |
1105 | - 'doing local rescan; user wants to connect, and network is available', |
1106 | + 'doing local rescan; user wants to connect, network is available', |
1107 | 'READING_WAITING_WITH_NETWORK', 'READING_WAITING_WITH_NETWORK', |
1108 | 'READING_WAITING', 'READING_WITH_NETWORK', |
1109 | 'READING_WAITING_WITH_NETWORK', |
1110 | @@ -331,55 +328,16 @@ |
1111 | SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_CONTQ', |
1112 | SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK', |
1113 | ) |
1114 | - |
1115 | -READING_WAITING_WITH_NETWORK_WITH_METAQ = SyncDaemonState( |
1116 | - 'READING_WAITING_WITH_NETWORK_WITH_METAQ', |
1117 | - 'doing local rescan; user wants to connect, network is available,' |
1118 | - ' meta_q waiting', |
1119 | - 'READING_WAITING_WITH_NETWORK_WITH_METAQ', |
1120 | - 'READING_WAITING_WITH_NETWORK_WITH_METAQ', |
1121 | - 'READING_WAITING_WITH_METAQ', 'READING_WITH_NETWORK_WITH_METAQ', |
1122 | - 'READING_WAITING_WITH_NETWORK_WITH_METAQ', |
1123 | - SYS_LOCAL_RESCAN_DONE='START_CONNECTING_WITH_METAQ', |
1124 | - SYS_META_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_METAQ', |
1125 | - SYS_META_QUEUE_DONE='READING_WAITING_WITH_NETWORK', |
1126 | - SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ', |
1127 | - SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_METAQ', |
1128 | - ) |
1129 | - |
1130 | -READING_WAITING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState( |
1131 | - 'READING_WAITING_WITH_NETWORK_WITH_CONTQ', |
1132 | - 'doing local rescan; user wants to connect, network is available,' |
1133 | - ' content_q waiting', |
1134 | - 'READING_WAITING_WITH_NETWORK_WITH_CONTQ', |
1135 | - 'READING_WAITING_WITH_NETWORK_WITH_CONTQ', |
1136 | - 'READING_WAITING_WITH_CONTQ', 'READING_WITH_NETWORK_WITH_CONTQ', |
1137 | - 'READING_WAITING_WITH_NETWORK_WITH_CONTQ', |
1138 | - SYS_LOCAL_RESCAN_DONE='START_CONNECTING_WITH_CONTQ', |
1139 | - SYS_META_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ', |
1140 | - SYS_META_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_CONTQ', |
1141 | - SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_CONTQ', |
1142 | - SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK', |
1143 | - ) |
1144 | - |
1145 | -READING_WAITING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState( |
1146 | - 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ', |
1147 | - 'doing local rescan; user wants to connect, network is available,' |
1148 | - ' both _q\'s waiting', |
1149 | - 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ', |
1150 | - 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ', |
1151 | - 'READING_WAITING_WITH_BOTHQ', 'READING_WITH_NETWORK_WITH_BOTHQ', |
1152 | - 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ', |
1153 | - SYS_LOCAL_RESCAN_DONE='START_CONNECTING_WITH_BOTHQ', |
1154 | - SYS_META_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ', |
1155 | - SYS_META_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_CONTQ', |
1156 | - SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ', |
1157 | - SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_METAQ', |
1158 | - ) |
1159 | +READING_WAITING_WITH_NETWORK_WITH_METAQ = \ |
1160 | + READING_WAITING_WITH_NETWORK.clone_with_metaq() |
1161 | +READING_WAITING_WITH_NETWORK_WITH_CONTQ = \ |
1162 | + READING_WAITING_WITH_NETWORK.clone_with_contq() |
1163 | +READING_WAITING_WITH_NETWORK_WITH_BOTHQ = \ |
1164 | + READING_WAITING_WITH_NETWORK.clone_with_bothq() |
1165 | |
1166 | READY_FOR_NETWORK = SyncDaemonState( |
1167 | 'READY_FOR_NETWORK', |
1168 | - 'ready to connect as soon as the user says so and the network comes up.', |
1169 | + 'ready to connect as soon as the user says so and the network comes up', |
1170 | 'READY_WITH_NETWORK', 'READY_WAITING', |
1171 | 'READY_FOR_NETWORK', 'READY_FOR_NETWORK', 'READY_FOR_NETWORK', |
1172 | SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_METAQ', |
1173 | @@ -387,49 +345,13 @@ |
1174 | SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_CONTQ', |
1175 | SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK', |
1176 | ) |
1177 | - |
1178 | -READY_FOR_NETWORK_WITH_METAQ = SyncDaemonState( |
1179 | - 'READY_FOR_NETWORK_WITH_METAQ', |
1180 | - 'ready to connect as soon as the user says so and the network comes up.' |
1181 | - + ' Meta queue is waiting.', |
1182 | - 'READY_WITH_NETWORK_WITH_METAQ', 'READY_WAITING_WITH_METAQ', |
1183 | - 'READY_FOR_NETWORK_WITH_METAQ', 'READY_FOR_NETWORK_WITH_METAQ', |
1184 | - 'READY_FOR_NETWORK_WITH_METAQ', |
1185 | - SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_METAQ', |
1186 | - SYS_META_QUEUE_DONE='READY_FOR_NETWORK', |
1187 | - SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ', |
1188 | - SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK_WITH_METAQ', |
1189 | - ) |
1190 | - |
1191 | -READY_FOR_NETWORK_WITH_CONTQ = SyncDaemonState( |
1192 | - 'READY_FOR_NETWORK_WITH_CONTQ', |
1193 | - 'ready to connect as soon as the user says so and the network comes up.' |
1194 | - + ' Content queue is waiting.', |
1195 | - 'READY_WITH_NETWORK_WITH_CONTQ', 'READY_WAITING_WITH_CONTQ', |
1196 | - 'READY_FOR_NETWORK_WITH_CONTQ', 'READY_FOR_NETWORK_WITH_CONTQ', |
1197 | - 'READY_FOR_NETWORK_WITH_CONTQ', |
1198 | - SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ', |
1199 | - SYS_META_QUEUE_DONE='READY_FOR_NETWORK_WITH_CONTQ', |
1200 | - SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_CONTQ', |
1201 | - SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK', |
1202 | - ) |
1203 | - |
1204 | -READY_FOR_NETWORK_WITH_BOTHQ = SyncDaemonState( |
1205 | - 'READY_FOR_NETWORK_WITH_BOTHQ', |
1206 | - 'ready to connect as soon as the user says so and the network comes up.' |
1207 | - + ' Both request queues are waiting.', |
1208 | - 'READY_WITH_NETWORK_WITH_BOTHQ', 'READY_WAITING_WITH_BOTHQ', |
1209 | - 'READY_FOR_NETWORK_WITH_BOTHQ', 'READY_FOR_NETWORK_WITH_BOTHQ', |
1210 | - 'READY_FOR_NETWORK_WITH_BOTHQ', |
1211 | - SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ', |
1212 | - SYS_META_QUEUE_DONE='READY_FOR_NETWORK_WITH_CONTQ', |
1213 | - SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ', |
1214 | - SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK_WITH_METAQ', |
1215 | - ) |
1216 | +READY_FOR_NETWORK_WITH_METAQ = READY_FOR_NETWORK.clone_with_metaq() |
1217 | +READY_FOR_NETWORK_WITH_CONTQ = READY_FOR_NETWORK.clone_with_contq() |
1218 | +READY_FOR_NETWORK_WITH_BOTHQ = READY_FOR_NETWORK.clone_with_bothq() |
1219 | |
1220 | READY_WITH_NETWORK = SyncDaemonState( |
1221 | 'READY_WITH_NETWORK', |
1222 | - 'ready to connect, network is up, user is yet to push "go"', |
1223 | + 'ready to connect, network up, user yet to push "go"', |
1224 | 'READY_WITH_NETWORK', 'START_CONNECTING', |
1225 | 'READY_FOR_NETWORK', 'READY_WITH_NETWORK', 'READY_WITH_NETWORK', |
1226 | SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_METAQ', |
1227 | @@ -437,42 +359,9 @@ |
1228 | SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_CONTQ', |
1229 | SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK', |
1230 | ) |
1231 | - |
1232 | -READY_WITH_NETWORK_WITH_METAQ = SyncDaemonState( |
1233 | - 'READY_WITH_NETWORK_WITH_METAQ', |
1234 | - 'ready to connect, network up, meta_q waiting, user yet to push "go"', |
1235 | - 'READY_WITH_NETWORK_WITH_METAQ', 'START_CONNECTING_WITH_METAQ', |
1236 | - 'READY_FOR_NETWORK_WITH_METAQ', 'READY_WITH_NETWORK_WITH_METAQ', |
1237 | - 'READY_WITH_NETWORK_WITH_METAQ', |
1238 | - SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_METAQ', |
1239 | - SYS_META_QUEUE_DONE='READY_WITH_NETWORK', |
1240 | - SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ', |
1241 | - SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK_WITH_METAQ', |
1242 | - ) |
1243 | - |
1244 | -READY_WITH_NETWORK_WITH_CONTQ = SyncDaemonState( |
1245 | - 'READY_WITH_NETWORK_WITH_CONTQ', |
1246 | - 'ready to connect, network up, content_q waiting, user yet to push "go"', |
1247 | - 'READY_WITH_NETWORK_WITH_CONTQ', 'START_CONNECTING_WITH_CONTQ', |
1248 | - 'READY_FOR_NETWORK_WITH_CONTQ', 'READY_WITH_NETWORK_WITH_CONTQ', |
1249 | - 'READY_WITH_NETWORK_WITH_CONTQ', |
1250 | - SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ', |
1251 | - SYS_META_QUEUE_DONE='READY_WITH_NETWORK_WITH_CONTQ', |
1252 | - SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_CONTQ', |
1253 | - SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK', |
1254 | - ) |
1255 | - |
1256 | -READY_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState( |
1257 | - 'READY_WITH_NETWORK_WITH_BOTHQ', |
1258 | - 'ready to connect, network up, both _q\'s waiting, user yet to push "go"', |
1259 | - 'READY_WITH_NETWORK_WITH_BOTHQ', 'START_CONNECTING_WITH_BOTHQ', |
1260 | - 'READY_FOR_NETWORK_WITH_BOTHQ', 'READY_WITH_NETWORK_WITH_BOTHQ', |
1261 | - 'READY_WITH_NETWORK_WITH_BOTHQ', |
1262 | - SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ', |
1263 | - SYS_META_QUEUE_DONE='READY_WITH_NETWORK_WITH_CONTQ', |
1264 | - SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ', |
1265 | - SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK_WITH_METAQ', |
1266 | - ) |
1267 | +READY_WITH_NETWORK_WITH_METAQ = READY_WITH_NETWORK.clone_with_metaq() |
1268 | +READY_WITH_NETWORK_WITH_CONTQ = READY_WITH_NETWORK.clone_with_contq() |
1269 | +READY_WITH_NETWORK_WITH_BOTHQ = READY_WITH_NETWORK.clone_with_bothq() |
1270 | |
1271 | READY_WAITING = SyncDaemonState( |
1272 | 'READY_WAITING', |
1273 | @@ -484,42 +373,106 @@ |
1274 | SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_CONTQ', |
1275 | SYS_CONTENT_QUEUE_DONE='READY_WAITING', |
1276 | ) |
1277 | - |
1278 | -READY_WAITING_WITH_METAQ = SyncDaemonState( |
1279 | - 'READY_WAITING_WITH_METAQ', |
1280 | - 'ready to connect; user said "go", network is down, meta_q waiting', |
1281 | - 'START_CONNECTING_WITH_METAQ', 'READY_WAITING_WITH_METAQ', |
1282 | - 'READY_WAITING_WITH_METAQ', 'READY_FOR_NETWORK_WITH_METAQ', |
1283 | - 'READY_WAITING_WITH_METAQ', |
1284 | - SYS_META_QUEUE_DONE='READY_WAITING', |
1285 | - SYS_META_QUEUE_WAITING='READY_WAITING_WITH_METAQ', |
1286 | - SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ', |
1287 | - SYS_CONTENT_QUEUE_DONE='READY_WAITING_WITH_METAQ', |
1288 | -) |
1289 | - |
1290 | -READY_WAITING_WITH_CONTQ = SyncDaemonState( |
1291 | - 'READY_WAITING_WITH_CONTQ', |
1292 | - 'ready to connect; user said "go", network is down, content_q waiting', |
1293 | - 'START_CONNECTING_WITH_CONTQ', 'READY_WAITING_WITH_CONTQ', |
1294 | - 'READY_WAITING_WITH_CONTQ', 'READY_FOR_NETWORK_WITH_CONTQ', |
1295 | - 'READY_WAITING_WITH_CONTQ', |
1296 | - SYS_META_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ', |
1297 | - SYS_META_QUEUE_DONE='READY_WAITING_WITH_CONTQ', |
1298 | - SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_CONTQ', |
1299 | - SYS_CONTENT_QUEUE_DONE='READY_WAITING', |
1300 | -) |
1301 | - |
1302 | -READY_WAITING_WITH_BOTHQ = SyncDaemonState( |
1303 | - 'READY_WAITING_WITH_BOTHQ', |
1304 | - 'ready to connect; user said "go", network is down, both _q\'s waiting', |
1305 | - 'START_CONNECTING_WITH_BOTHQ', 'READY_WAITING_WITH_BOTHQ', |
1306 | - 'READY_WAITING_WITH_BOTHQ', 'READY_FOR_NETWORK_WITH_BOTHQ', |
1307 | - 'READY_WAITING_WITH_BOTHQ', |
1308 | - SYS_META_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ', |
1309 | - SYS_META_QUEUE_DONE='READY_WAITING_WITH_CONTQ', |
1310 | - SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ', |
1311 | - SYS_CONTENT_QUEUE_DONE='READY_WAITING_WITH_METAQ', |
1312 | -) |
1313 | +READY_WAITING_WITH_METAQ = READY_WAITING.clone_with_metaq() |
1314 | +READY_WAITING_WITH_CONTQ = READY_WAITING.clone_with_contq() |
1315 | +READY_WAITING_WITH_BOTHQ = READY_WAITING.clone_with_bothq() |
1316 | + |
1317 | +START_STANDOFF_WAITING_WITH_NETWORK = SyncDaemonState( |
1318 | + 'START_STANDOFF_WAITING_WITH_NETWORK', |
1319 | + 'disconnect and wait for SYS_CONNECTION_LOST, then go on to connect', |
1320 | + 'STANDOFF_WAITING_WITH_NETWORK', 'STANDOFF_WAITING_WITH_NETWORK', |
1321 | + 'STANDOFF_WAITING', 'STANDOFF_WITH_NETWORK', |
1322 | + 'START_CONNECTING', |
1323 | + SYS_META_QUEUE_WAITING='STANDOFF_WAITING_WITH_NETWORK_WITH_METAQ', |
1324 | + SYS_META_QUEUE_DONE='STANDOFF_WAITING_WITH_NETWORK', |
1325 | + SYS_CONTENT_QUEUE_WAITING='STANDOFF_WAITING_WITH_NETWORK_WITH_CONTQ', |
1326 | + SYS_CONTENT_QUEUE_DONE='STANDOFF_WAITING_WITH_NETWORK', |
1327 | + enter=lambda m: m.action_q.disconnect(), |
1328 | +) |
1329 | +START_STANDOFF_WAITING_WITH_NETWORK_WITH_METAQ = \ |
1330 | + START_STANDOFF_WAITING_WITH_NETWORK.clone_with_metaq() |
1331 | +START_STANDOFF_WAITING_WITH_NETWORK_WITH_CONTQ = \ |
1332 | + START_STANDOFF_WAITING_WITH_NETWORK.clone_with_contq() |
1333 | +START_STANDOFF_WAITING_WITH_NETWORK_WITH_BOTHQ = \ |
1334 | + START_STANDOFF_WAITING_WITH_NETWORK.clone_with_bothq() |
1335 | +STANDOFF_WAITING_WITH_NETWORK = \ |
1336 | + START_STANDOFF_WAITING_WITH_NETWORK.clone_with_no_start( |
1337 | + 'wait for SYS_CONNECTION_LOST, then go on to connect') |
1338 | +STANDOFF_WAITING_WITH_NETWORK_WITH_METAQ = \ |
1339 | + STANDOFF_WAITING_WITH_NETWORK.clone_with_metaq() |
1340 | +STANDOFF_WAITING_WITH_NETWORK_WITH_CONTQ = \ |
1341 | + STANDOFF_WAITING_WITH_NETWORK.clone_with_contq() |
1342 | +STANDOFF_WAITING_WITH_NETWORK_WITH_BOTHQ = \ |
1343 | + STANDOFF_WAITING_WITH_NETWORK.clone_with_bothq() |
1344 | + |
1345 | +START_STANDOFF_WITH_NETWORK = SyncDaemonState( |
1346 | + 'START_STANDOFF_WITH_NETWORK', |
1347 | + 'disconnect and wait for SYS_CONNECTION_LOST;' |
1348 | + ' network present, but asked not to connect', |
1349 | + 'STANDOFF_WITH_NETWORK', 'STANDOFF_WAITING_WITH_NETWORK', |
1350 | + 'STANDOFF', 'STANDOFF_WITH_NETWORK', |
1351 | + 'READY_WITH_NETWORK', |
1352 | + SYS_META_QUEUE_WAITING='STANDOFF_WITH_NETWORK_WITH_METAQ', |
1353 | + SYS_META_QUEUE_DONE='STANDOFF_WITH_NETWORK', |
1354 | + SYS_CONTENT_QUEUE_WAITING='STANDOFF_WITH_NETWORK_WITH_CONTQ', |
1355 | + SYS_CONTENT_QUEUE_DONE='STANDOFF_WITH_NETWORK', |
1356 | + enter=lambda m: m.action_q.disconnect(), |
1357 | +) |
1358 | +START_STANDOFF_WITH_NETWORK_WITH_METAQ = \ |
1359 | + START_STANDOFF_WITH_NETWORK.clone_with_metaq() |
1360 | +START_STANDOFF_WITH_NETWORK_WITH_CONTQ = \ |
1361 | + START_STANDOFF_WITH_NETWORK.clone_with_contq() |
1362 | +START_STANDOFF_WITH_NETWORK_WITH_BOTHQ = \ |
1363 | + START_STANDOFF_WITH_NETWORK.clone_with_bothq() |
1364 | +STANDOFF_WITH_NETWORK = START_STANDOFF_WITH_NETWORK.clone_with_no_start( |
1365 | + 'wait for SYS_CONNECTION_LOST; network present, but asked not to connect') |
1366 | +STANDOFF_WITH_NETWORK_WITH_METAQ = STANDOFF_WITH_NETWORK.clone_with_metaq() |
1367 | +STANDOFF_WITH_NETWORK_WITH_CONTQ = STANDOFF_WITH_NETWORK.clone_with_contq() |
1368 | +STANDOFF_WITH_NETWORK_WITH_BOTHQ = STANDOFF_WITH_NETWORK.clone_with_bothq() |
1369 | + |
1370 | +START_STANDOFF_WAITING = SyncDaemonState( |
1371 | + 'START_STANDOFF_WAITING', |
1372 | + 'disconnect and wait for SYS_CONNECTION_LOST;' |
1373 | + ' wanting to connect but no network present', |
1374 | + 'STANDOFF_WAITING_WITH_NETWORK', 'STANDOFF_WAITING', |
1375 | + 'STANDOFF_WAITING', 'STANDOFF', |
1376 | + 'READY_WAITING', |
1377 | + SYS_META_QUEUE_WAITING='STANDOFF_WAITING_WITH_METAQ', |
1378 | + SYS_META_QUEUE_DONE='STANDOFF_WAITING', |
1379 | + SYS_CONTENT_QUEUE_WAITING='STANDOFF_WAITING_WITH_CONTQ', |
1380 | + SYS_CONTENT_QUEUE_DONE='STANDOFF_WAITING', |
1381 | + enter=lambda m: m.action_q.disconnect(), |
1382 | +) |
1383 | +START_STANDOFF_WAITING_WITH_METAQ = START_STANDOFF_WAITING.clone_with_metaq() |
1384 | +START_STANDOFF_WAITING_WITH_CONTQ = START_STANDOFF_WAITING.clone_with_contq() |
1385 | +START_STANDOFF_WAITING_WITH_BOTHQ = START_STANDOFF_WAITING.clone_with_bothq() |
1386 | +STANDOFF_WAITING = START_STANDOFF_WAITING.clone_with_no_start( |
1387 | + 'wait for SYS_CONNECTION_LOST; wanting to connect but no network present') |
1388 | +STANDOFF_WAITING_WITH_METAQ = STANDOFF_WAITING.clone_with_metaq() |
1389 | +STANDOFF_WAITING_WITH_CONTQ = STANDOFF_WAITING.clone_with_contq() |
1390 | +STANDOFF_WAITING_WITH_BOTHQ = STANDOFF_WAITING.clone_with_bothq() |
1391 | + |
1392 | +START_STANDOFF = SyncDaemonState( |
1393 | + 'START_STANDOFF', |
1394 | + 'disconnect and wait for SYS_CONNECTION_LOST;' |
1395 | + ' no network present, not wanting to connect', |
1396 | + 'STANDOFF_WITH_NETWORK', 'STANDOFF_WAITING', |
1397 | + 'STANDOFF', 'STANDOFF', |
1398 | + 'READY_FOR_NETWORK', |
1399 | + SYS_META_QUEUE_WAITING='STANDOFF_WITH_METAQ', |
1400 | + SYS_META_QUEUE_DONE='STANDOFF', |
1401 | + SYS_CONTENT_QUEUE_WAITING='STANDOFF_WITH_CONTQ', |
1402 | + SYS_CONTENT_QUEUE_DONE='STANDOFF', |
1403 | + enter=lambda m: m.action_q.disconnect(), |
1404 | +) |
1405 | +START_STANDOFF_WITH_METAQ = START_STANDOFF.clone_with_metaq() |
1406 | +START_STANDOFF_WITH_CONTQ = START_STANDOFF.clone_with_contq() |
1407 | +START_STANDOFF_WITH_BOTHQ = START_STANDOFF.clone_with_bothq() |
1408 | +STANDOFF = START_STANDOFF.clone_with_no_start( |
1409 | + 'wait for SYS_CONNECTION_LOST; no network present, not wanting to connect') |
1410 | +STANDOFF_WITH_METAQ = STANDOFF.clone_with_metaq() |
1411 | +STANDOFF_WITH_CONTQ = STANDOFF.clone_with_contq() |
1412 | +STANDOFF_WITH_BOTHQ = STANDOFF.clone_with_bothq() |
1413 | |
1414 | START_CONNECTING = SyncDaemonState( |
1415 | 'START_CONNECTING', |
1416 | @@ -531,109 +484,18 @@ |
1417 | SYS_META_QUEUE_DONE='CONNECTING', |
1418 | SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ', |
1419 | SYS_CONTENT_QUEUE_DONE='CONNECTING', |
1420 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING', |
1421 | - enter=lambda m: m.action_q.connect(), |
1422 | - ) |
1423 | - |
1424 | -START_CONNECTING_WITH_METAQ = SyncDaemonState( |
1425 | - 'START_CONNECTING_WITH_METAQ', |
1426 | - 'started waiting for the socket to come up; meta_q waiting', |
1427 | - 'CONNECTING_WITH_METAQ', 'CONNECTING_WITH_METAQ', |
1428 | - 'READY_WAITING_WITH_METAQ', 'READY_WITH_NETWORK_WITH_METAQ', |
1429 | - 'START_CONNECTING_WITH_METAQ', |
1430 | - SYS_CONNECTION_MADE='START_CONNECTED_WITH_METAQ', |
1431 | - SYS_META_QUEUE_WAITING='CONNECTING_WITH_METAQ', |
1432 | - SYS_META_QUEUE_DONE='CONNECTING', |
1433 | - SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ', |
1434 | - SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ', |
1435 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ', |
1436 | - enter=lambda m: m.action_q.connect(), |
1437 | - ) |
1438 | - |
1439 | -START_CONNECTING_WITH_CONTQ = SyncDaemonState( |
1440 | - 'START_CONNECTING_WITH_CONTQ', |
1441 | - 'started waiting for the socket to come up; content_q waiting', |
1442 | - 'CONNECTING_WITH_CONTQ', 'CONNECTING_WITH_CONTQ', |
1443 | - 'READY_WAITING_WITH_CONTQ', 'READY_WITH_NETWORK_WITH_CONTQ', |
1444 | - 'START_CONNECTING_WITH_CONTQ', |
1445 | - SYS_CONNECTION_MADE='START_CONNECTED_WITH_CONTQ', |
1446 | - SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ', |
1447 | - SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ', |
1448 | - SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ', |
1449 | - SYS_CONTENT_QUEUE_DONE='CONNECTING', |
1450 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ', |
1451 | - enter=lambda m: m.action_q.connect(), |
1452 | - ) |
1453 | - |
1454 | -START_CONNECTING_WITH_BOTHQ = SyncDaemonState( |
1455 | - 'START_CONNECTING_WITH_BOTHQ', |
1456 | - 'started waiting for the socket to come up; both _q\'s waiting', |
1457 | - 'CONNECTING_WITH_BOTHQ', 'CONNECTING_WITH_BOTHQ', |
1458 | - 'READY_WAITING_WITH_BOTHQ', 'READY_WITH_NETWORK_WITH_BOTHQ', |
1459 | - 'START_CONNECTING_WITH_BOTHQ', |
1460 | - SYS_CONNECTION_MADE='START_CONNECTED_WITH_BOTHQ', |
1461 | - SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ', |
1462 | - SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ', |
1463 | - SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ', |
1464 | - SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ', |
1465 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ', |
1466 | - enter=lambda m: m.action_q.connect(), |
1467 | - ) |
1468 | - |
1469 | -CONNECTING = SyncDaemonState( |
1470 | - 'CONNECTING', |
1471 | - 'waiting for the socket to come up', |
1472 | - 'CONNECTING', 'CONNECTING', |
1473 | - 'READY_WAITING', 'READY_WITH_NETWORK', 'START_CONNECTING', |
1474 | - SYS_CONNECTION_MADE='START_CONNECTED', |
1475 | - SYS_META_QUEUE_WAITING='CONNECTING_WITH_METAQ', |
1476 | - SYS_META_QUEUE_DONE='CONNECTING', |
1477 | - SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ', |
1478 | - SYS_CONTENT_QUEUE_DONE='CONNECTING', |
1479 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING', |
1480 | - ) |
1481 | - |
1482 | -CONNECTING_WITH_METAQ = SyncDaemonState( |
1483 | - 'CONNECTING_WITH_METAQ', |
1484 | - 'waiting for the socket to come up; meta_q waiting', |
1485 | - 'CONNECTING_WITH_METAQ', 'CONNECTING_WITH_METAQ', |
1486 | - 'READY_WAITING_WITH_METAQ', 'READY_WITH_NETWORK_WITH_METAQ', |
1487 | - 'START_CONNECTING_WITH_METAQ', |
1488 | - SYS_CONNECTION_MADE='START_CONNECTED_WITH_METAQ', |
1489 | - SYS_META_QUEUE_WAITING='CONNECTING_WITH_METAQ', |
1490 | - SYS_META_QUEUE_DONE='CONNECTING', |
1491 | - SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ', |
1492 | - SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ', |
1493 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ', |
1494 | - ) |
1495 | - |
1496 | -CONNECTING_WITH_CONTQ = SyncDaemonState( |
1497 | - 'CONNECTING_WITH_CONTQ', |
1498 | - 'waiting for the socket to come up; content_q waiting', |
1499 | - 'CONNECTING_WITH_CONTQ', 'CONNECTING_WITH_CONTQ', |
1500 | - 'READY_WAITING_WITH_CONTQ', 'READY_WITH_NETWORK_WITH_CONTQ', |
1501 | - 'START_CONNECTING_WITH_CONTQ', |
1502 | - SYS_CONNECTION_MADE='START_CONNECTED_WITH_CONTQ', |
1503 | - SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ', |
1504 | - SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ', |
1505 | - SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ', |
1506 | - SYS_CONTENT_QUEUE_DONE='CONNECTING', |
1507 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ', |
1508 | - ) |
1509 | - |
1510 | -CONNECTING_WITH_BOTHQ = SyncDaemonState( |
1511 | - 'CONNECTING_WITH_BOTHQ', |
1512 | - 'waiting for the socket to come up; both _q\'s waiting', |
1513 | - 'CONNECTING_WITH_BOTHQ', 'CONNECTING_WITH_BOTHQ', |
1514 | - 'READY_WAITING_WITH_BOTHQ', 'READY_WITH_NETWORK_WITH_BOTHQ', |
1515 | - 'START_CONNECTING_WITH_BOTHQ', |
1516 | - SYS_CONNECTION_MADE='START_CONNECTED_WITH_BOTHQ', |
1517 | - SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ', |
1518 | - SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ', |
1519 | - SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ', |
1520 | - SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ', |
1521 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ', |
1522 | - ) |
1523 | + SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK', |
1524 | + enter=lambda m: m.action_q.connect(), |
1525 | + ) |
1526 | +START_CONNECTING_WITH_METAQ = START_CONNECTING.clone_with_metaq() |
1527 | +START_CONNECTING_WITH_CONTQ = START_CONNECTING.clone_with_contq() |
1528 | +START_CONNECTING_WITH_BOTHQ = START_CONNECTING.clone_with_bothq() |
1529 | + |
1530 | +CONNECTING = START_CONNECTING.clone_with_no_start( |
1531 | + 'waiting for the socket to come up') |
1532 | +CONNECTING_WITH_METAQ = CONNECTING.clone_with_metaq() |
1533 | +CONNECTING_WITH_CONTQ = CONNECTING.clone_with_contq() |
1534 | +CONNECTING_WITH_BOTHQ = CONNECTING.clone_with_bothq() |
1535 | |
1536 | START_CONNECTED = NonActiveConnectedSDState( |
1537 | 'START_CONNECTED', |
1538 | @@ -644,102 +506,17 @@ |
1539 | SYS_META_QUEUE_DONE='CONNECTED', |
1540 | SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ', |
1541 | SYS_CONTENT_QUEUE_DONE='CONNECTED', |
1542 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING', |
1543 | - enter=lambda m: m.check_version(), |
1544 | - ) |
1545 | - |
1546 | -START_CONNECTED_WITH_METAQ = NonActiveConnectedSDState( |
1547 | - 'START_CONNECTED_WITH_METAQ', |
1548 | - 'socket came up! start checking protocol version; meta_q waiting', |
1549 | - with_q='METAQ', |
1550 | - SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION', |
1551 | - SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_METAQ', |
1552 | - SYS_META_QUEUE_WAITING='CONNECTED_WITH_METAQ', |
1553 | - SYS_META_QUEUE_DONE='CONNECTED', |
1554 | - SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ', |
1555 | - SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ', |
1556 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ', |
1557 | - enter=lambda m: m.check_version(), |
1558 | - ) |
1559 | - |
1560 | -START_CONNECTED_WITH_CONTQ = NonActiveConnectedSDState( |
1561 | - 'START_CONNECTED_WITH_CONTQ', |
1562 | - 'socket came up! start checking protocol version; content_q waiting', |
1563 | - with_q='CONTQ', |
1564 | - SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION', |
1565 | - SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_CONTQ', |
1566 | - SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ', |
1567 | - SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ', |
1568 | - SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ', |
1569 | - SYS_CONTENT_QUEUE_DONE='CONNECTED', |
1570 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ', |
1571 | - enter=lambda m: m.check_version(), |
1572 | - ) |
1573 | - |
1574 | -START_CONNECTED_WITH_BOTHQ = NonActiveConnectedSDState( |
1575 | - 'START_CONNECTED_WITH_BOTHQ', |
1576 | - 'socket came up! start checking protocol version both _q\'s waiting', |
1577 | - with_q='BOTHQ', |
1578 | - SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION', |
1579 | - SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_BOTHQ', |
1580 | - SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ', |
1581 | - SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ', |
1582 | - SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ', |
1583 | - SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ', |
1584 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ', |
1585 | - enter=lambda m: m.check_version(), |
1586 | - ) |
1587 | - |
1588 | -CONNECTED = NonActiveConnectedSDState( |
1589 | - 'CONNECTED', |
1590 | - 'socket came up! checking protocol version', |
1591 | - SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION', |
1592 | - SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES', |
1593 | - SYS_META_QUEUE_WAITING='CONNECTED_WITH_METAQ', |
1594 | - SYS_META_QUEUE_DONE='CONNECTED', |
1595 | - SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ', |
1596 | - SYS_CONTENT_QUEUE_DONE='CONNECTED', |
1597 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING', |
1598 | - ) |
1599 | - |
1600 | -CONNECTED_WITH_METAQ = NonActiveConnectedSDState( |
1601 | - 'CONNECTED_WITH_METAQ', |
1602 | - 'socket came up! checking protocol version; meta_q waiting', |
1603 | - with_q='METAQ', |
1604 | - SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION', |
1605 | - SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_METAQ', |
1606 | - SYS_META_QUEUE_WAITING='CONNECTED_WITH_METAQ', |
1607 | - SYS_META_QUEUE_DONE='CONNECTED', |
1608 | - SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ', |
1609 | - SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ', |
1610 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ', |
1611 | - ) |
1612 | - |
1613 | -CONNECTED_WITH_CONTQ = NonActiveConnectedSDState( |
1614 | - 'CONNECTED_WITH_CONTQ', |
1615 | - 'socket came up! checking protocol version; content_q waiting', |
1616 | - with_q='CONTQ', |
1617 | - SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION', |
1618 | - SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_CONTQ', |
1619 | - SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ', |
1620 | - SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ', |
1621 | - SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ', |
1622 | - SYS_CONTENT_QUEUE_DONE='CONNECTED', |
1623 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ', |
1624 | - ) |
1625 | - |
1626 | -CONNECTED_WITH_BOTHQ = NonActiveConnectedSDState( |
1627 | - 'CONNECTED_WITH_BOTHQ', |
1628 | - 'socket came up! checking protocol version both _q\'s waiting', |
1629 | - with_q='BOTHQ', |
1630 | - SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION', |
1631 | - SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_BOTHQ', |
1632 | - SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ', |
1633 | - SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ', |
1634 | - SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ', |
1635 | - SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ', |
1636 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ', |
1637 | - ) |
1638 | + SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK', |
1639 | + enter=lambda m: m.check_version(), |
1640 | + ) |
1641 | +START_CONNECTED_WITH_METAQ = START_CONNECTED.clone_with_metaq() |
1642 | +START_CONNECTED_WITH_CONTQ = START_CONNECTED.clone_with_contq() |
1643 | +START_CONNECTED_WITH_BOTHQ = START_CONNECTED.clone_with_bothq() |
1644 | +CONNECTED = START_CONNECTED.clone_with_no_start('socket came up!' |
1645 | + ' checking protocol version') |
1646 | +CONNECTED_WITH_METAQ = CONNECTED.clone_with_metaq() |
1647 | +CONNECTED_WITH_CONTQ = CONNECTED.clone_with_contq() |
1648 | +CONNECTED_WITH_BOTHQ = CONNECTED.clone_with_bothq() |
1649 | |
1650 | BAD_VERSION = AQErrorState( |
1651 | 'BAD_VERSION', |
1652 | @@ -755,102 +532,17 @@ |
1653 | SYS_META_QUEUE_DONE='SET_CAPABILITIES', |
1654 | SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ', |
1655 | SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES', |
1656 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING', |
1657 | - enter=lambda m: m.set_capabilities(), |
1658 | - ) |
1659 | - |
1660 | -START_SET_CAPABILITIES_WITH_METAQ = NonActiveConnectedSDState( |
1661 | - 'START_SET_CAPABILITIES_WITH_METAQ', |
1662 | - 'protocol version is OK! start checking capabilities; meta_q waiting', |
1663 | - with_q='METAQ', |
1664 | - SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH', |
1665 | - SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_METAQ', |
1666 | - SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_METAQ', |
1667 | - SYS_META_QUEUE_DONE='SET_CAPABILITIES', |
1668 | - SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ', |
1669 | - SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ', |
1670 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ', |
1671 | - enter=lambda m: m.set_capabilities(), |
1672 | - ) |
1673 | - |
1674 | -START_SET_CAPABILITIES_WITH_CONTQ = NonActiveConnectedSDState( |
1675 | - 'START_SET_CAPABILITIES_WITH_CONTQ', |
1676 | - 'protocol version is OK! start checking capabilities; content_q waiting', |
1677 | - with_q='CONTQ', |
1678 | - SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH', |
1679 | - SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_CONTQ', |
1680 | - SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ', |
1681 | - SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ', |
1682 | - SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ', |
1683 | - SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES', |
1684 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ', |
1685 | - enter=lambda m: m.set_capabilities(), |
1686 | - ) |
1687 | - |
1688 | -START_SET_CAPABILITIES_WITH_BOTHQ = NonActiveConnectedSDState( |
1689 | - 'START_SET_CAPABILITIES_WITH_BOTHQ', |
1690 | - 'protocol version is OK! start checking capabilities; both _q\'s waiting', |
1691 | - with_q='BOTHQ', |
1692 | - SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH', |
1693 | - SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_BOTHQ', |
1694 | - SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ', |
1695 | - SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ', |
1696 | - SYS_CONTENT_QUEUE_WAITING='START_SET_CAPABILITIES_WITH_BOTHQ', |
1697 | - SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ', |
1698 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ', |
1699 | - enter=lambda m: m.set_capabilities(), |
1700 | - ) |
1701 | - |
1702 | -SET_CAPABILITIES = NonActiveConnectedSDState( |
1703 | - 'SET_CAPABILITIES', |
1704 | - 'capabilities OK, do the auth!', |
1705 | - SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH', |
1706 | - SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING', |
1707 | - SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_METAQ', |
1708 | - SYS_META_QUEUE_DONE='SET_CAPABILITIES', |
1709 | - SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ', |
1710 | - SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES', |
1711 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING', |
1712 | - ) |
1713 | - |
1714 | -SET_CAPABILITIES_WITH_METAQ = NonActiveConnectedSDState( |
1715 | - 'SET_CAPABILITIES_WITH_METAQ', |
1716 | - 'capabilities OK, do the auth!; meta_q waiting', |
1717 | - with_q='METAQ', |
1718 | - SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH', |
1719 | - SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_METAQ', |
1720 | - SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_METAQ', |
1721 | - SYS_META_QUEUE_DONE='SET_CAPABILITIES', |
1722 | - SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ', |
1723 | - SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ', |
1724 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ', |
1725 | - ) |
1726 | - |
1727 | -SET_CAPABILITIES_WITH_CONTQ = NonActiveConnectedSDState( |
1728 | - 'SET_CAPABILITIES_WITH_CONTQ', |
1729 | - 'capabilities OK, do the auth!; cont_q waiting', |
1730 | - with_q='CONTQ', |
1731 | - SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH', |
1732 | - SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_CONTQ', |
1733 | - SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ', |
1734 | - SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ', |
1735 | - SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ', |
1736 | - SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES', |
1737 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ', |
1738 | - ) |
1739 | - |
1740 | -SET_CAPABILITIES_WITH_BOTHQ = NonActiveConnectedSDState( |
1741 | - 'SET_CAPABILITIES_WITH_BOTHQ', |
1742 | - 'capabilities OK, do the auth!; both _q\'s waiting', |
1743 | - with_q='BOTHQ', |
1744 | - SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH', |
1745 | - SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_BOTHQ', |
1746 | - SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ', |
1747 | - SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ', |
1748 | - SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ', |
1749 | - SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ', |
1750 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ', |
1751 | - ) |
1752 | + SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK', |
1753 | + enter=lambda m: m.set_capabilities(), |
1754 | + ) |
1755 | +START_SET_CAPABILITIES_WITH_METAQ = START_SET_CAPABILITIES.clone_with_metaq() |
1756 | +START_SET_CAPABILITIES_WITH_CONTQ = START_SET_CAPABILITIES.clone_with_contq() |
1757 | +START_SET_CAPABILITIES_WITH_BOTHQ = START_SET_CAPABILITIES.clone_with_bothq() |
1758 | +SET_CAPABILITIES = START_SET_CAPABILITIES.clone_with_no_start( |
1759 | + 'protocol version is OK! checking capabilities') |
1760 | +SET_CAPABILITIES_WITH_METAQ = SET_CAPABILITIES.clone_with_metaq() |
1761 | +SET_CAPABILITIES_WITH_CONTQ = SET_CAPABILITIES.clone_with_contq() |
1762 | +SET_CAPABILITIES_WITH_BOTHQ = SET_CAPABILITIES.clone_with_bothq() |
1763 | |
1764 | CAPABILITIES_MISMATCH = AQErrorState( |
1765 | 'CAPABILITIES_MISMATCH', |
1766 | @@ -860,108 +552,23 @@ |
1767 | START_AUTHENTICATING = NonActiveConnectedSDState( |
1768 | 'START_AUTHENTICATING', |
1769 | 'Start doing the OAuth dance', |
1770 | - SYS_OAUTH_OK='SCANNING_START', |
1771 | - SYS_OAUTH_ERROR='AUTH_FAILED', |
1772 | - SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ', |
1773 | - SYS_META_QUEUE_DONE='AUTHENTICATING', |
1774 | - SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ', |
1775 | - SYS_CONTENT_QUEUE_DONE='AUTHENTICATING', |
1776 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING', |
1777 | - enter=lambda m: m.authenticate(), |
1778 | - ) |
1779 | - |
1780 | -START_AUTHENTICATING_WITH_METAQ = NonActiveConnectedSDState( |
1781 | - 'START_AUTHENTICATING_WITH_METAQ', |
1782 | - 'Start doing the OAuth dance; meta_q waiting', |
1783 | - with_q='METAQ', |
1784 | - SYS_OAUTH_OK='SCANNING_START_WITH_METAQ', |
1785 | - SYS_OAUTH_ERROR='AUTH_FAILED', |
1786 | - SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ', |
1787 | - SYS_META_QUEUE_DONE='AUTHENTICATING', |
1788 | - SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ', |
1789 | - SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ', |
1790 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ', |
1791 | - enter=lambda m: m.authenticate(), |
1792 | - ) |
1793 | - |
1794 | -START_AUTHENTICATING_WITH_CONTQ = NonActiveConnectedSDState( |
1795 | - 'START_AUTHENTICATING_WITH_CONTQ', |
1796 | - 'Start doing the OAuth dance; content_q waiting', |
1797 | - with_q='CONTQ', |
1798 | - SYS_OAUTH_OK='SCANNING_START_WITH_CONTQ', |
1799 | - SYS_OAUTH_ERROR='AUTH_FAILED', |
1800 | - SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ', |
1801 | - SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ', |
1802 | - SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ', |
1803 | - SYS_CONTENT_QUEUE_DONE='AUTHENTICATING', |
1804 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ', |
1805 | - enter=lambda m: m.authenticate(), |
1806 | - ) |
1807 | - |
1808 | -START_AUTHENTICATING_WITH_BOTHQ = NonActiveConnectedSDState( |
1809 | - 'START_AUTHENTICATING_WITH_BOTHQ', |
1810 | - 'Start doing the OAuth dance; both _q\'s waiting', |
1811 | - with_q='CONTQ', |
1812 | - SYS_OAUTH_OK='SCANNING_START_WITH_BOTHQ', |
1813 | - SYS_OAUTH_ERROR='AUTH_FAILED', |
1814 | - SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ', |
1815 | - SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ', |
1816 | - SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ', |
1817 | - SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ', |
1818 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ', |
1819 | - enter=lambda m: m.authenticate(), |
1820 | - ) |
1821 | - |
1822 | -AUTHENTICATING = NonActiveConnectedSDState( |
1823 | - 'AUTHENTICATING', |
1824 | - 'Doing the OAuth dance', |
1825 | - SYS_OAUTH_OK='SCANNING_START', |
1826 | - SYS_OAUTH_ERROR='AUTH_FAILED', |
1827 | - SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ', |
1828 | - SYS_META_QUEUE_DONE='AUTHENTICATING', |
1829 | - SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ', |
1830 | - SYS_CONTENT_QUEUE_DONE='AUTHENTICATING', |
1831 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING', |
1832 | - ) |
1833 | - |
1834 | -AUTHENTICATING_WITH_METAQ = NonActiveConnectedSDState( |
1835 | - 'AUTHENTICATING_WITH_METAQ', |
1836 | - 'Doing the OAuth dance; meta_q waiting', |
1837 | - with_q='METAQ', |
1838 | - SYS_OAUTH_OK='SCANNING_START_WITH_METAQ', |
1839 | - SYS_OAUTH_ERROR='AUTH_FAILED', |
1840 | - SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ', |
1841 | - SYS_META_QUEUE_DONE='AUTHENTICATING', |
1842 | - SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ', |
1843 | - SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ', |
1844 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ', |
1845 | - ) |
1846 | - |
1847 | -AUTHENTICATING_WITH_CONTQ = NonActiveConnectedSDState( |
1848 | - 'AUTHENTICATING_WITH_CONTQ', |
1849 | - 'Doing the OAuth dance; content_q waiting', |
1850 | - with_q='CONTQ', |
1851 | - SYS_OAUTH_OK='SCANNING_START_WITH_CONTQ', |
1852 | - SYS_OAUTH_ERROR='AUTH_FAILED', |
1853 | - SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ', |
1854 | - SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ', |
1855 | - SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ', |
1856 | - SYS_CONTENT_QUEUE_DONE='AUTHENTICATING', |
1857 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ', |
1858 | - ) |
1859 | - |
1860 | -AUTHENTICATING_WITH_BOTHQ = NonActiveConnectedSDState( |
1861 | - 'AUTHENTICATING_WITH_BOTHQ', |
1862 | - 'Doing the OAuth dance; both _q\'s waiting', |
1863 | - with_q='CONTQ', |
1864 | - SYS_OAUTH_OK='SCANNING_START_WITH_BOTHQ', |
1865 | - SYS_OAUTH_ERROR='AUTH_FAILED', |
1866 | - SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ', |
1867 | - SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ', |
1868 | - SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ', |
1869 | - SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ', |
1870 | - SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ', |
1871 | - ) |
1872 | + SYS_OAUTH_OK='START_SCANNING', |
1873 | + SYS_OAUTH_ERROR='AUTH_FAILED', |
1874 | + SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ', |
1875 | + SYS_META_QUEUE_DONE='AUTHENTICATING', |
1876 | + SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ', |
1877 | + SYS_CONTENT_QUEUE_DONE='AUTHENTICATING', |
1878 | + SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK', |
1879 | + enter=lambda m: m.authenticate(), |
1880 | + ) |
1881 | +START_AUTHENTICATING_WITH_METAQ = START_AUTHENTICATING.clone_with_metaq() |
1882 | +START_AUTHENTICATING_WITH_CONTQ = START_AUTHENTICATING.clone_with_contq() |
1883 | +START_AUTHENTICATING_WITH_BOTHQ = START_AUTHENTICATING.clone_with_bothq() |
1884 | +AUTHENTICATING = START_AUTHENTICATING.clone_with_no_start( |
1885 | + 'Doing the OAuth dance') |
1886 | +AUTHENTICATING_WITH_METAQ = AUTHENTICATING.clone_with_metaq() |
1887 | +AUTHENTICATING_WITH_CONTQ = AUTHENTICATING.clone_with_contq() |
1888 | +AUTHENTICATING_WITH_BOTHQ = AUTHENTICATING.clone_with_bothq() |
1889 | |
1890 | AUTH_FAILED = AQErrorState( |
1891 | 'AUTH_FAILED', |
1892 | @@ -976,8 +583,8 @@ |
1893 | "Some kind of strange error happened and I can't continue", |
1894 | enter=lambda m: m.restart()) |
1895 | |
1896 | -SCANNING_START = NonActiveConnectedSDState( |
1897 | - 'SCANNING_START', |
1898 | +START_SCANNING = NonActiveConnectedSDState( |
1899 | + 'START_SCANNING', |
1900 | 'start doing server rescan', |
1901 | SYS_SERVER_RESCAN_STARTING='SCANNING', |
1902 | SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ', |
1903 | @@ -986,89 +593,17 @@ |
1904 | SYS_CONTENT_QUEUE_DONE='SCANNING', |
1905 | enter=lambda m: m.server_rescan(), |
1906 | ) |
1907 | - |
1908 | -SCANNING_START_WITH_METAQ = NonActiveConnectedSDState( |
1909 | - 'SCANNING_START_WITH_METAQ', |
1910 | - 'start doing server rescan, meta queue is waiting', |
1911 | - with_q='METAQ', |
1912 | - SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_METAQ', |
1913 | - SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ', |
1914 | - SYS_META_QUEUE_DONE='SCANNING', |
1915 | - SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ', |
1916 | - SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ', |
1917 | - enter=lambda m: m.server_rescan(), |
1918 | - ) |
1919 | - |
1920 | -SCANNING_START_WITH_CONTQ = NonActiveConnectedSDState( |
1921 | - 'SCANNING_START_WITH_CONTQ', |
1922 | - 'start doing server rescan, content queue waiting', |
1923 | - with_q='CONTQ', |
1924 | - SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_CONTQ', |
1925 | - SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ', |
1926 | - SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ', |
1927 | - SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_CONTQ', |
1928 | - SYS_CONTENT_QUEUE_DONE='SCANNING', |
1929 | - enter=lambda m: m.server_rescan(), |
1930 | - ) |
1931 | - |
1932 | -SCANNING_START_WITH_BOTHQ = NonActiveConnectedSDState( |
1933 | - 'SCANNING_START_WITH_BOTHQ', |
1934 | - 'start doing server rescan, both request queues waiting', |
1935 | - with_q='CONTQ', |
1936 | - SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_BOTHQ', |
1937 | - SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ', |
1938 | - SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ', |
1939 | - SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ', |
1940 | - SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ', |
1941 | - enter=lambda m: m.server_rescan(), |
1942 | - ) |
1943 | - |
1944 | -SCANNING = NonActiveConnectedSDState( |
1945 | - 'SCANNING', |
1946 | - 'doing server rescan', |
1947 | - SYS_SERVER_RESCAN_DONE='IDLE', |
1948 | - SYS_SERVER_RESCAN_STARTING='SCANNING', |
1949 | - SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ', |
1950 | - SYS_META_QUEUE_DONE='SCANNING', |
1951 | - SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_CONTQ', |
1952 | - SYS_CONTENT_QUEUE_DONE='SCANNING', |
1953 | - ) |
1954 | - |
1955 | -SCANNING_WITH_METAQ = NonActiveConnectedSDState( |
1956 | - 'SCANNING_WITH_METAQ', |
1957 | - 'doing server rescan, meta queue is waiting', |
1958 | - with_q='METAQ', |
1959 | - SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA', |
1960 | - SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_METAQ', |
1961 | - SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ', |
1962 | - SYS_META_QUEUE_DONE='SCANNING', |
1963 | - SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ', |
1964 | - SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ', |
1965 | - ) |
1966 | - |
1967 | -SCANNING_WITH_CONTQ = NonActiveConnectedSDState( |
1968 | - 'SCANNING_WITH_CONTQ', |
1969 | - 'doing server rescan, content queue waiting', |
1970 | - with_q='CONTQ', |
1971 | - SYS_SERVER_RESCAN_DONE='START_WORKING_ON_CONTENT', |
1972 | - SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_CONTQ', |
1973 | - SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ', |
1974 | - SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ', |
1975 | - SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_CONTQ', |
1976 | - SYS_CONTENT_QUEUE_DONE='SCANNING', |
1977 | - ) |
1978 | - |
1979 | -SCANNING_WITH_BOTHQ = NonActiveConnectedSDState( |
1980 | - 'SCANNING_WITH_BOTHQ', |
1981 | - 'doing server rescan, both request queues waiting', |
1982 | - with_q='CONTQ', |
1983 | - SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA_WITH_CONTQ', |
1984 | - SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_BOTHQ', |
1985 | - SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ', |
1986 | - SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ', |
1987 | - SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ', |
1988 | - SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ', |
1989 | - ) |
1990 | +START_SCANNING_WITH_METAQ = START_SCANNING.clone_with_metaq() |
1991 | +START_SCANNING_WITH_CONTQ = START_SCANNING.clone_with_contq() |
1992 | +START_SCANNING_WITH_BOTHQ = START_SCANNING.clone_with_bothq() |
1993 | +SCANNING = START_SCANNING.clone_with_no_start('doing server rescan', |
1994 | + SYS_SERVER_RESCAN_DONE='IDLE') |
1995 | +SCANNING_WITH_METAQ = SCANNING.clone_with_metaq( |
1996 | + SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA') |
1997 | +SCANNING_WITH_CONTQ = SCANNING.clone_with_contq( |
1998 | + SYS_SERVER_RESCAN_DONE='START_WORKING_ON_CONTENT') |
1999 | +SCANNING_WITH_BOTHQ = SCANNING.clone_with_bothq( |
2000 | + SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA_WITH_CONTQ') |
2001 | |
2002 | IDLE = NonActiveConnectedSDState( |
2003 | 'IDLE', |
2004 | @@ -1089,15 +624,8 @@ |
2005 | SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA', |
2006 | enter=lambda m: m.action_q.meta_queue.run(), |
2007 | ) |
2008 | - |
2009 | -WORKING_ON_METADATA = WorkingSDState( |
2010 | - 'WORKING_ON_METADATA', |
2011 | - 'working on metadata', |
2012 | - SYS_META_QUEUE_WAITING='WORKING_ON_METADATA', |
2013 | - SYS_META_QUEUE_DONE='IDLE', |
2014 | - SYS_CONTENT_QUEUE_WAITING='WORKING_ON_METADATA_WITH_CONTQ', |
2015 | - SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA', |
2016 | - ) |
2017 | +WORKING_ON_METADATA = START_WORKING_ON_METADATA.clone_with_no_start( |
2018 | + 'working on metadata') |
2019 | |
2020 | START_WORKING_ON_CONTENT = WorkingSDState( |
2021 | 'START_WORKING_ON_CONTENT', |
2022 | @@ -1108,15 +636,8 @@ |
2023 | SYS_CONTENT_QUEUE_DONE='IDLE', |
2024 | enter=lambda m: m.action_q.content_queue.run(), |
2025 | ) |
2026 | - |
2027 | -WORKING_ON_CONTENT = WorkingSDState( |
2028 | - 'WORKING_ON_CONTENT', |
2029 | - 'working on content', |
2030 | - SYS_META_QUEUE_WAITING='START_WORKING_ON_BOTH', |
2031 | - SYS_META_QUEUE_DONE='WORKING_ON_CONTENT', |
2032 | - SYS_CONTENT_QUEUE_WAITING='WORKING_ON_CONTENT', |
2033 | - SYS_CONTENT_QUEUE_DONE='IDLE', |
2034 | - ) |
2035 | +WORKING_ON_CONTENT = START_WORKING_ON_CONTENT.clone_with_no_start( |
2036 | + 'working on content') |
2037 | |
2038 | START_WORKING_ON_METADATA_WITH_CONTQ = WorkingSDState( |
2039 | 'START_WORKING_ON_METADATA_WITH_CONTQ', |
2040 | @@ -1128,364 +649,208 @@ |
2041 | SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA', |
2042 | enter=lambda m: m.action_q.meta_queue.run(), |
2043 | ) |
2044 | - |
2045 | -WORKING_ON_METADATA_WITH_CONTQ = WorkingSDState( |
2046 | - 'WORKING_ON_METADATA_WITH_CONTQ', |
2047 | - 'working on metadata; content work is waiting', |
2048 | - with_q='CONTQ', |
2049 | - SYS_META_QUEUE_WAITING='WORKING_ON_METADATA_WITH_CONTQ', |
2050 | - SYS_META_QUEUE_DONE='START_WORKING_ON_CONTENT', |
2051 | - SYS_CONTENT_QUEUE_WAITING='WORKING_ON_METADATA_WITH_CONTQ', |
2052 | - SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA', |
2053 | - ) |
2054 | +WORKING_ON_METADATA_WITH_CONTQ = \ |
2055 | + START_WORKING_ON_METADATA_WITH_CONTQ.clone_with_no_start( |
2056 | + 'working on metadata; content work is waiting') |
2057 | |
2058 | START_WORKING_ON_BOTH = WorkingSDState( |
2059 | 'START_WORKING_ON_BOTH', |
2060 | 'start working on both content and metadata', |
2061 | - with_q='BOTHQ', |
2062 | SYS_META_QUEUE_WAITING='WORKING_ON_BOTH', |
2063 | SYS_META_QUEUE_DONE='WORKING_ON_CONTENT', |
2064 | SYS_CONTENT_QUEUE_WAITING='WORKING_ON_BOTH', |
2065 | SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA', |
2066 | enter=lambda m: m.action_q.meta_queue.run(), |
2067 | ) |
2068 | - |
2069 | -WORKING_ON_BOTH = WorkingSDState( |
2070 | - 'WORKING_ON_BOTH', |
2071 | - 'working on both content and metadata', |
2072 | - with_q='BOTHQ', |
2073 | - SYS_META_QUEUE_WAITING='WORKING_ON_BOTH', |
2074 | - SYS_META_QUEUE_DONE='WORKING_ON_CONTENT', |
2075 | - SYS_CONTENT_QUEUE_WAITING='WORKING_ON_BOTH', |
2076 | - SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA', |
2077 | - ) |
2078 | +WORKING_ON_BOTH = START_WORKING_ON_BOTH.clone_with_no_start( |
2079 | + 'working on both content and metadata') |
2080 | |
2081 | CLEANUP = SyncDaemonState( |
2082 | 'CLEANUP', |
2083 | - 'doing cleanup (net down, user asked for shutdown)', |
2084 | + 'doing cleanup; net down, user asked for shutdown', |
2085 | 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING', |
2086 | - 'CLEANUP', 'CLEANUP', 'CLEANUP', |
2087 | + 'CLEANUP', 'CLEANUP', 'CLEANUP_WITH_CONNECTION_LOST', |
2088 | SYS_CLEANUP_STARTED='CLEANUP', |
2089 | - SYS_CLEANUP_FINISHED='READY_FOR_NETWORK', |
2090 | + SYS_CLEANUP_FINISHED='START_STANDOFF', |
2091 | SYS_META_QUEUE_WAITING='CLEANUP_WITH_METAQ', |
2092 | SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONTQ', |
2093 | SYS_META_QUEUE_DONE='CLEANUP', # cancelling meta_q.head can do this |
2094 | SYS_CONTENT_QUEUE_DONE='CLEANUP', # ditto |
2095 | ) |
2096 | - |
2097 | -CLEANUP_WITH_METAQ = SyncDaemonState( |
2098 | - 'CLEANUP_WITH_METAQ', |
2099 | - 'doing cleanup (net down, user asked for shutdown, meta_q waiting)', |
2100 | - 'CLEANUP_WITH_NETWORK_WITH_METAQ', 'CLEANUP_WAITING_WITH_METAQ', |
2101 | - 'CLEANUP_WITH_METAQ', 'CLEANUP_WITH_METAQ', 'CLEANUP_WITH_METAQ', |
2102 | - SYS_CLEANUP_STARTED='CLEANUP_WITH_METAQ', |
2103 | - SYS_CLEANUP_FINISHED='READY_FOR_NETWORK_WITH_METAQ', |
2104 | - SYS_META_QUEUE_WAITING='CLEANUP_WITH_METAQ', |
2105 | - SYS_META_QUEUE_DONE='CLEANUP', |
2106 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_BOTHQ', |
2107 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_METAQ', |
2108 | - ) |
2109 | - |
2110 | -CLEANUP_WITH_CONTQ = SyncDaemonState( |
2111 | - 'CLEANUP_WITH_CONTQ', |
2112 | - 'doing cleanup (net down, user asked for shutdown, content_q waiting)', |
2113 | - 'CLEANUP_WITH_NETWORK_WITH_CONTQ', 'CLEANUP_WAITING_WITH_CONTQ', |
2114 | - 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_CONTQ', |
2115 | - SYS_CLEANUP_STARTED='CLEANUP_WITH_CONTQ', |
2116 | - SYS_CLEANUP_FINISHED='READY_FOR_NETWORK_WITH_CONTQ', |
2117 | - SYS_META_QUEUE_WAITING='CLEANUP_WITH_BOTHQ', |
2118 | - SYS_META_QUEUE_DONE='CLEANUP_WITH_CONTQ', |
2119 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONTQ', |
2120 | - SYS_CONTENT_QUEUE_DONE='CLEANUP', |
2121 | - ) |
2122 | - |
2123 | -CLEANUP_WITH_BOTHQ = SyncDaemonState( |
2124 | - 'CLEANUP_WITH_BOTHQ', |
2125 | - 'doing cleanup (net down, user asked for shutdown, both _q\'s waiting)', |
2126 | - 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', 'CLEANUP_WAITING_WITH_BOTHQ', |
2127 | - 'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ', |
2128 | - SYS_CLEANUP_STARTED='CLEANUP_WITH_BOTHQ', |
2129 | - SYS_CLEANUP_FINISHED='READY_FOR_NETWORK_WITH_BOTHQ', |
2130 | - SYS_META_QUEUE_WAITING='CLEANUP_WITH_BOTHQ', |
2131 | - SYS_META_QUEUE_DONE='CLEANUP_WITH_CONTQ', |
2132 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_BOTHQ', |
2133 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_METAQ', |
2134 | - ) |
2135 | +CLEANUP_WITH_METAQ = CLEANUP.clone_with_metaq() |
2136 | +CLEANUP_WITH_CONTQ = CLEANUP.clone_with_contq() |
2137 | +CLEANUP_WITH_BOTHQ = CLEANUP.clone_with_bothq() |
2138 | + |
2139 | +CLEANUP_WITH_CONNECTION_LOST = SyncDaemonState( |
2140 | + 'CLEANUP_WITH_CONNECTION_LOST', |
2141 | + 'doing cleanup; net down, user asked for shutdown, connection already lost', |
2142 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2143 | + 'CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2144 | + 'CLEANUP_WITH_CONNECTION_LOST', |
2145 | + 'CLEANUP_WITH_CONNECTION_LOST', |
2146 | + 'CLEANUP_WITH_CONNECTION_LOST', |
2147 | + SYS_CLEANUP_STARTED='CLEANUP_WITH_CONNECTION_LOST', |
2148 | + SYS_CLEANUP_FINISHED='START_STANDOFF', |
2149 | + SYS_META_QUEUE_WAITING='CLEANUP_WITH_CONNECTION_LOST_WITH_METAQ', |
2150 | + SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONNECTION_LOST_WITH_CONTQ', |
2151 | + SYS_META_QUEUE_DONE='CLEANUP_WITH_CONNECTION_LOST', |
2152 | + SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_CONNECTION_LOST', |
2153 | + ) |
2154 | +CLEANUP_WITH_CONNECTION_LOST_WITH_METAQ = \ |
2155 | + CLEANUP_WITH_CONNECTION_LOST.clone_with_metaq() |
2156 | +CLEANUP_WITH_CONNECTION_LOST_WITH_CONTQ = \ |
2157 | + CLEANUP_WITH_CONNECTION_LOST.clone_with_contq() |
2158 | +CLEANUP_WITH_CONNECTION_LOST_WITH_BOTHQ = \ |
2159 | + CLEANUP_WITH_CONNECTION_LOST.clone_with_bothq() |
2160 | |
2161 | START_CLEANUP_WAITING = SyncDaemonState( |
2162 | 'START_CLEANUP_WAITING', |
2163 | - 'start doing cleanup (network dropped)', |
2164 | - 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING', |
2165 | - 'CLEANUP_WAITING', 'CLEANUP', 'CLEANUP_WAITING', |
2166 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING', |
2167 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ', |
2168 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ', |
2169 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING', |
2170 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING', |
2171 | - enter=lambda m: m.action_q.cleanup(), |
2172 | - ) |
2173 | - |
2174 | -START_CLEANUP_WAITING_WITH_CONTQ = SyncDaemonState( |
2175 | - 'START_CLEANUP_WAITING_WITH_CONTQ', |
2176 | - 'start doing cleanup (network dropped; contq waiting)', |
2177 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2178 | - 'CLEANUP_WAITING_WITH_CONTQ', |
2179 | - 'CLEANUP_WAITING_WITH_CONTQ', 'CLEANUP_WITH_CONTQ', |
2180 | - 'CLEANUP_WAITING_WITH_CONTQ', |
2181 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_CONTQ', |
2182 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ', |
2183 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ', |
2184 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ', |
2185 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING', |
2186 | - enter=lambda m: m.action_q.cleanup(), |
2187 | - ) |
2188 | - |
2189 | -START_CLEANUP_WAITING_WITH_BOTHQ = SyncDaemonState( |
2190 | - 'START_CLEANUP_WAITING_WITH_BOTHQ', |
2191 | - 'start doing cleanup (network dropped; bothq waiting)', |
2192 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2193 | - 'CLEANUP_WAITING_WITH_BOTHQ', |
2194 | - 'CLEANUP_WAITING_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ', |
2195 | - 'CLEANUP_WAITING_WITH_BOTHQ', |
2196 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_BOTHQ', |
2197 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ', |
2198 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ', |
2199 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ', |
2200 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_METAQ', |
2201 | - enter=lambda m: m.action_q.cleanup(), |
2202 | - ) |
2203 | - |
2204 | -CLEANUP_WAITING = SyncDaemonState( |
2205 | - 'CLEANUP_WAITING', |
2206 | - 'doing cleanup (network dropped)', |
2207 | - 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING', |
2208 | - 'CLEANUP_WAITING', 'CLEANUP', 'CLEANUP_WAITING', |
2209 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING', |
2210 | - SYS_CLEANUP_FINISHED='READY_WAITING', |
2211 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ', |
2212 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ', |
2213 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING', |
2214 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING', |
2215 | - ) |
2216 | - |
2217 | -CLEANUP_WAITING_WITH_METAQ = SyncDaemonState( |
2218 | - 'CLEANUP_WAITING_WITH_METAQ', |
2219 | - 'doing cleanup (network dropped, meta_q waiting)', |
2220 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', 'CLEANUP_WAITING_WITH_METAQ', |
2221 | - 'CLEANUP_WAITING_WITH_METAQ', 'CLEANUP_WITH_METAQ', |
2222 | - 'CLEANUP_WAITING_WITH_METAQ', |
2223 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_METAQ', |
2224 | - SYS_CLEANUP_FINISHED='READY_WAITING_WITH_METAQ', |
2225 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ', |
2226 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING', |
2227 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ', |
2228 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_METAQ', |
2229 | - ) |
2230 | - |
2231 | -CLEANUP_WAITING_WITH_CONTQ = SyncDaemonState( |
2232 | - 'CLEANUP_WAITING_WITH_CONTQ', |
2233 | - 'doing cleanup (network dropped, content_q waiting)', |
2234 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', 'CLEANUP_WAITING_WITH_CONTQ', |
2235 | - 'CLEANUP_WAITING_WITH_CONTQ', 'CLEANUP_WITH_CONTQ', |
2236 | - 'CLEANUP_WAITING_WITH_CONTQ', |
2237 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_CONTQ', |
2238 | - SYS_CLEANUP_FINISHED='READY_WAITING_WITH_CONTQ', |
2239 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ', |
2240 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ', |
2241 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ', |
2242 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING', |
2243 | - ) |
2244 | - |
2245 | -CLEANUP_WAITING_WITH_BOTHQ = SyncDaemonState( |
2246 | - 'CLEANUP_WAITING_WITH_BOTHQ', |
2247 | - 'doing cleanup (network dropped, both _q\'s waiting)', |
2248 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', 'CLEANUP_WAITING_WITH_BOTHQ', |
2249 | - 'CLEANUP_WAITING_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ', |
2250 | - 'CLEANUP_WAITING_WITH_BOTHQ', |
2251 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_BOTHQ', |
2252 | - SYS_CLEANUP_FINISHED='READY_WAITING_WITH_BOTHQ', |
2253 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ', |
2254 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ', |
2255 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ', |
2256 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_METAQ', |
2257 | - ) |
2258 | + 'start doing cleanup; network dropped', |
2259 | + 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING', |
2260 | + 'CLEANUP_WAITING', 'CLEANUP', |
2261 | + 'CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2262 | + SYS_CLEANUP_STARTED='CLEANUP_WAITING', |
2263 | + SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ', |
2264 | + SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ', |
2265 | + SYS_META_QUEUE_DONE='CLEANUP_WAITING', |
2266 | + SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING', |
2267 | + enter=lambda m: m.action_q.cleanup(), |
2268 | + ) |
2269 | +START_CLEANUP_WAITING_WITH_CONTQ = START_CLEANUP_WAITING.clone_with_contq() |
2270 | +# START_CLEANUP_WAITING_WITH_BOTHQ = START_CLEANUP_WAITING.clone_with_bothq() |
2271 | +CLEANUP_WAITING = START_CLEANUP_WAITING.clone_with_no_start( |
2272 | + 'doing cleanup; network dropped', |
2273 | + SYS_CLEANUP_FINISHED='START_STANDOFF_WAITING') |
2274 | +CLEANUP_WAITING_WITH_METAQ = CLEANUP_WAITING.clone_with_metaq() |
2275 | +CLEANUP_WAITING_WITH_CONTQ = CLEANUP_WAITING.clone_with_contq() |
2276 | +CLEANUP_WAITING_WITH_BOTHQ = CLEANUP_WAITING.clone_with_bothq() |
2277 | + |
2278 | |
2279 | CLEANUP_WITH_NETWORK = SyncDaemonState( |
2280 | 'CLEANUP_WITH_NETWORK', |
2281 | - 'doing cleanup (net hiccup; user asked for shutdown)', |
2282 | + 'doing cleanup; net hiccup, user asked for shutdown', |
2283 | 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK', |
2284 | - 'CLEANUP', 'CLEANUP_WITH_NETWORK', 'CLEANUP_WITH_NETWORK', |
2285 | + 'CLEANUP', 'CLEANUP_WITH_NETWORK', |
2286 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2287 | SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK', |
2288 | + SYS_CLEANUP_FINISHED='START_STANDOFF_WITH_NETWORK', |
2289 | + SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ', |
2290 | + SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2291 | + SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK', |
2292 | + SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK', |
2293 | + ) |
2294 | +CLEANUP_WITH_NETWORK_WITH_METAQ = CLEANUP_WITH_NETWORK.clone_with_metaq() |
2295 | +CLEANUP_WITH_NETWORK_WITH_CONTQ = CLEANUP_WITH_NETWORK.clone_with_contq() |
2296 | +CLEANUP_WITH_NETWORK_WITH_BOTHQ = CLEANUP_WITH_NETWORK.clone_with_bothq() |
2297 | + |
2298 | +CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST = SyncDaemonState( |
2299 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2300 | + 'doing cleanup; net hiccup, user asked to shutdown, ' |
2301 | + 'already got SYS_CONNECTION_LOST', |
2302 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2303 | + 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2304 | + 'CLEANUP_WITH_CONNECTION_LOST', |
2305 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2306 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2307 | + SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2308 | SYS_CLEANUP_FINISHED='READY_WITH_NETWORK', |
2309 | - SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ', |
2310 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2311 | - SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK', |
2312 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK', |
2313 | - ) |
2314 | - |
2315 | -CLEANUP_WITH_NETWORK_WITH_METAQ = SyncDaemonState( |
2316 | - 'CLEANUP_WITH_NETWORK_WITH_METAQ', |
2317 | - 'doing cleanup (net hiccup; user asked for shutdown; meta_q waiting)', |
2318 | - 'CLEANUP_WITH_NETWORK_WITH_METAQ', |
2319 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2320 | - 'CLEANUP_WITH_METAQ', 'CLEANUP_WITH_NETWORK_WITH_METAQ', |
2321 | - 'CLEANUP_WITH_NETWORK_WITH_METAQ', |
2322 | - SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_METAQ', |
2323 | - SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_METAQ', |
2324 | - SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ', |
2325 | - SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK', |
2326 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2327 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_METAQ', |
2328 | - ) |
2329 | - |
2330 | -CLEANUP_WITH_NETWORK_WITH_CONTQ = SyncDaemonState( |
2331 | - 'CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2332 | - 'doing cleanup (net hiccup; user asked for shutdown; content_q waiting)', |
2333 | - 'CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2334 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2335 | - 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2336 | - 'CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2337 | - SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2338 | - SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_CONTQ', |
2339 | - SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2340 | - SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2341 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2342 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK', |
2343 | - ) |
2344 | - |
2345 | -CLEANUP_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState( |
2346 | - 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2347 | - 'doing cleanup (net hiccup; user asked for shutdown; both _q\'s waiting)', |
2348 | - 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2349 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2350 | - 'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2351 | - 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2352 | - SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2353 | - SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_BOTHQ', |
2354 | - SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2355 | - SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2356 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2357 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_METAQ', |
2358 | - ) |
2359 | + SYS_META_QUEUE_WAITING=\ |
2360 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ', |
2361 | + SYS_CONTENT_QUEUE_WAITING=\ |
2362 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ', |
2363 | + SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2364 | + SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2365 | +) |
2366 | +CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ = \ |
2367 | + CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_metaq() |
2368 | +CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ = \ |
2369 | + CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_contq() |
2370 | +CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_BOTHQ = \ |
2371 | + CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_bothq() |
2372 | |
2373 | CLEANUP_WAITING_WITH_NETWORK = SyncDaemonState( |
2374 | 'CLEANUP_WAITING_WITH_NETWORK', |
2375 | - 'doing cleanup (network hiccup)', |
2376 | + 'doing cleanup; network hiccup', |
2377 | 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK', |
2378 | 'CLEANUP_WAITING', 'CLEANUP_WITH_NETWORK', |
2379 | - 'CLEANUP_WAITING_WITH_NETWORK', |
2380 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK', |
2381 | - SYS_CLEANUP_FINISHED='START_CONNECTING', |
2382 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2383 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2384 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK', |
2385 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK', |
2386 | - ) |
2387 | - |
2388 | -START_CLEANUP_WAITING_WITH_NETWORK = SyncDaemonState( |
2389 | - 'START_CLEANUP_WAITING_WITH_NETWORK', |
2390 | - 'doing cleanup (network hiccup)', |
2391 | - 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK', |
2392 | - 'CLEANUP_WAITING', 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK', |
2393 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK', |
2394 | - SYS_CLEANUP_FINISHED='START_CONNECTING', |
2395 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2396 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2397 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK', |
2398 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK', |
2399 | - enter=lambda m: m.action_q.cleanup(), |
2400 | - ) |
2401 | - |
2402 | -START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState( |
2403 | - 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2404 | - 'doing cleanup (network hiccup; cont_q waiting)', |
2405 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2406 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2407 | - 'CLEANUP_WAITING_WITH_CONTQ', |
2408 | - 'CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2409 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2410 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2411 | - SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_CONTQ', |
2412 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2413 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2414 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2415 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK', |
2416 | - enter=lambda m: m.action_q.cleanup(), |
2417 | - ) |
2418 | - |
2419 | -START_CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState( |
2420 | - 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2421 | - 'doing cleanup (network hiccup; both _q\'s waiting)', |
2422 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2423 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2424 | - 'CLEANUP_WAITING_WITH_BOTHQ', |
2425 | - 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2426 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2427 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2428 | - SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_BOTHQ', |
2429 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2430 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2431 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2432 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2433 | - enter=lambda m: m.action_q.cleanup(), |
2434 | - ) |
2435 | - |
2436 | -CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ = SyncDaemonState( |
2437 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2438 | - 'doing cleanup (network hiccup; meta_q waiting)', |
2439 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2440 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2441 | - 'CLEANUP_WAITING_WITH_METAQ', 'CLEANUP_WITH_NETWORK_WITH_METAQ', |
2442 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2443 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2444 | - SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_METAQ', |
2445 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2446 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK', |
2447 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2448 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2449 | - ) |
2450 | - |
2451 | -CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState( |
2452 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2453 | - 'doing cleanup (network hiccup; content_q waiting)', |
2454 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2455 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2456 | - 'CLEANUP_WAITING_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2457 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2458 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2459 | - SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_CONTQ', |
2460 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2461 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2462 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2463 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK', |
2464 | - ) |
2465 | - |
2466 | -CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState( |
2467 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2468 | - 'doing cleanup (network hiccup; both _q\'s waiting)', |
2469 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2470 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2471 | - 'CLEANUP_WAITING_WITH_BOTHQ', 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2472 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2473 | - SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2474 | - SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_BOTHQ', |
2475 | - SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2476 | - SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2477 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2478 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2479 | - ) |
2480 | - |
2481 | - |
2482 | + 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2483 | + SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK', |
2484 | + SYS_CLEANUP_FINISHED='START_STANDOFF_WAITING_WITH_NETWORK', |
2485 | + SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', |
2486 | + SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2487 | + SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK', |
2488 | + SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK', |
2489 | + ) |
2490 | +CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ = \ |
2491 | + CLEANUP_WAITING_WITH_NETWORK.clone_with_metaq() |
2492 | +CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ = \ |
2493 | + CLEANUP_WAITING_WITH_NETWORK.clone_with_contq() |
2494 | +CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ = \ |
2495 | + CLEANUP_WAITING_WITH_NETWORK.clone_with_bothq() |
2496 | + |
2497 | +START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST = SyncDaemonState( |
2498 | + 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2499 | + 'start doing cleanup; network hiccup, already got SYS_CONNECTION_LOST', |
2500 | + 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2501 | + 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2502 | + 'CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2503 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2504 | + 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2505 | + SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2506 | + SYS_META_QUEUE_WAITING=\ |
2507 | + 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ', |
2508 | + SYS_CONTENT_QUEUE_WAITING=\ |
2509 | + 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ', |
2510 | + SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2511 | + SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2512 | + enter=lambda m: m.action_q.cleanup(), |
2513 | +) |
2514 | +START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ = \ |
2515 | + START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_contq() |
2516 | +CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST = \ |
2517 | + START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_no_start( |
2518 | + 'doing cleanup; network hiccup, already got SYS_CONNECTION_LOST', |
2519 | + SYS_CLEANUP_FINISHED='START_CONNECTING') |
2520 | +CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ = \ |
2521 | + CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_metaq() |
2522 | +CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ = \ |
2523 | + CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_contq() |
2524 | +CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_BOTHQ = \ |
2525 | + CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_bothq() |
2526 | + |
2527 | +CLEANUP_WAITING_WITH_CONNECTION_LOST = SyncDaemonState( |
2528 | + 'CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2529 | + 'doing cleanup; network down, connection already lost', |
2530 | + 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST', |
2531 | + 'CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2532 | + 'CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2533 | + 'CLEANUP_WITH_CONNECTION_LOST', |
2534 | + 'CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2535 | + SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2536 | + SYS_CLEANUP_FINISHED='READY_WAITING', |
2537 | + SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_METAQ', |
2538 | + SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_CONTQ', |
2539 | + SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2540 | + SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_CONNECTION_LOST', |
2541 | + ) |
2542 | +CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_METAQ = \ |
2543 | + CLEANUP_WAITING_WITH_CONNECTION_LOST.clone_with_metaq() |
2544 | +CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_CONTQ = \ |
2545 | + CLEANUP_WAITING_WITH_CONNECTION_LOST.clone_with_contq() |
2546 | +CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_BOTHQ = \ |
2547 | + CLEANUP_WAITING_WITH_CONNECTION_LOST.clone_with_bothq() |
2548 | |
2549 | # XXX CONNECTED_CLEANUP should use the network to do a "better" cleanup |
2550 | +# XXX the way it stands the cloning methods are useless |
2551 | START_CONNECTED_CLEANUP = SyncDaemonState( |
2552 | 'START_CONNECTED_CLEANUP', |
2553 | 'start doing cleanup using the network' |
2554 | ' (not yet implemented; actually starts a plain cleanup)', |
2555 | 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK', |
2556 | - 'CLEANUP', 'CLEANUP_WITH_NETWORK', 'CLEANUP_WITH_NETWORK', |
2557 | + 'CLEANUP', 'CLEANUP_WITH_NETWORK', |
2558 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST', |
2559 | SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK', |
2560 | - SYS_CLEANUP_FINISHED='READY_WITH_NETWORK', |
2561 | + SYS_CLEANUP_FINISHED='START_STANDOFF_WITH_NETWORK', |
2562 | SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ', |
2563 | SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2564 | SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK', |
2565 | @@ -1500,29 +865,12 @@ |
2566 | 'CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2567 | 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', |
2568 | 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2569 | - 'CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2570 | + 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ', |
2571 | SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2572 | - SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_CONTQ', |
2573 | + SYS_CLEANUP_FINISHED='START_STANDOFF_WITH_NETWORK_WITH_CONTQ', |
2574 | SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2575 | SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2576 | SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2577 | SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK', |
2578 | enter=lambda m: m.action_q.cleanup(), |
2579 | ) |
2580 | - |
2581 | -START_CONNECTED_CLEANUP_WITH_BOTHQ = SyncDaemonState( |
2582 | - 'START_CONNECTED_CLEANUP_WITH_BOTHQ', |
2583 | - 'start doing cleanup using the network' |
2584 | - ' (not yet implemented; actually starts a plain cleanup)', |
2585 | - 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2586 | - 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', |
2587 | - 'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2588 | - 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2589 | - SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2590 | - SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_BOTHQ', |
2591 | - SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2592 | - SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ', |
2593 | - SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ', |
2594 | - SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_METAQ', |
2595 | - enter=lambda m: m.action_q.cleanup(), |
2596 | - ) |
This fixes #420354 which is about BadTransitions happening due to there being multiple active connections on the client (e.g. one going down, one going up). We now step a little more carefully through the disconnection states.
It's a big branch, unfortunately. In order to have confidence that I wasn't making a mess of things this close to Karmic, I reworked what used to be a static checker into actual test cases; the states now have ~4k tests. ck_states.py is no more, as all its tests were copied into the test cases. I also pruned the duplicate code in states.py a lot by adding a few cloning methods; this isn't the refactoring states.py needs, but it will enable somebody else to do that refactoring if I'm hit by a bus. I also believe I wouldn't've been able to add the STANDOFF states without this pruning; as it is, it's a mind-bender.