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