Ubuntu One Client

Merge lp:~chipaca/ubuntuone-client/really-fix-duplicate-connections into lp:ubuntuone-client

  1. really-fix-duplicate-connections
  2. 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
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)

To post a comment you must log in.
Revision history for this message
John Lenton (chipaca) wrote :

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.

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
=== removed file 'contrib/ck_states.py'
--- contrib/ck_states.py 2009-08-12 19:05:14 +0000
+++ contrib/ck_states.py 1970-01-01 00:00:00 +0000
@@ -1,142 +0,0 @@
1"""
2This is a sanity checker for the humongous ball of dragonspit that is
3ubuntuone.syncdaemon.states
4"""
5
6import re
7
8from ubuntuone.syncdaemon import states, event_queue
9
10
11all_states = dict((k, v) for (k, v) in vars(states).items()
12 if isinstance(v, states.SyncDaemonState))
13
14is_start = re.compile(r'(?:^START_|_START(?:_WITH_[^_]+Q)?$)').search
15has_q = re.compile(r'_WITH_([^_]+)Q$|^(?:START_)?WORKING_ON_(....)').search
16
17all_trns = set(sum((state.transitions.values()
18 for state in all_states.values()), []))
19
20for name, state in sorted(all_states.items()):
21 if name != state.name:
22 # the name of the object and the object's name attribute
23 # should be the same
24 print name, 'says it is called', state.name
25
26 if isinstance(state, states.WorkingSDState):
27 if state.with_q is None and has_q(name):
28 # WorkingSDState instances that have a name such as
29 # FOO_WITH_METAQ should be initialized with with_q='META'
30 print name, 'should have with_q!'
31 elif state.with_q and not name.endswith(state.with_q):
32 print name, 'says it is with_q', state.with_q
33
34 # check the state is 'reachable'
35 if name not in all_trns:
36 print name, 'is not the target of any transition!'
37
38 # check the events and final states mentioned in the transitions
39 # all exist
40 for evt, trn in sorted(state.transitions.items()):
41 if evt not in event_queue.EVENTS:
42 print '%s responds to %s event which 404' % (name, trn)
43 if trn not in all_states:
44 print '%s --[%s]--> %s which 404' % (name, evt, trn)
45
46 if is_start(name):
47 # checks specific to START states
48 if state.enter is None:
49 # a START state with no enter is not a START state at all
50 print name, 'has no enter'
51 other_name = re.sub(r'_START|START_', '', name)
52 if other_name not in all_states:
53 # a START state with no homonymous non-START state?
54 if not name.startswith('START_CONNECTED_CLEANUP'):
55 print name, 'has no non-starter'
56 else:
57 # a START state and its homonymous non-START state should
58 # handle pretty much the same events, and react in similar
59 # ways
60 other = all_states[other_name]
61 this_trn = set(state.transitions)
62 other_trn = set(other.transitions)
63 only_in_this = this_trn - other_trn
64 only_in_other = other_trn - this_trn \
65 - set(['SYS_SERVER_RESCAN_DONE', 'SYS_CLEANUP_FINISHED'])
66 if only_in_this:
67 # an event in the START state is not handled by the non-START
68 print 'missing from %s: %s' % (other_name,
69 ", ".join(sorted(only_in_this)))
70 if only_in_other:
71 # viceversa
72 print 'missing from %s: %s' % (name,
73 ", ".join(sorted(only_in_other)))
74 for trn in sorted(this_trn.intersection(other_trn)):
75 if state.transitions[trn] != other.transitions[trn]:
76 # the is handled, but differently
77 if not (name == state.transitions[trn]
78 and other.name == other.transitions[trn]):
79 print '%s pushes %s --> %s, but %s --> %s' % \
80 (trn, name, state.transitions[trn],
81 other.name, other.transitions[trn])
82 else:
83 if state.enter is not None:
84 # a non-START state with an enter is actually a START state
85 print name, 'has enter'
86
87 # most states that have a _WITH_<some>Q should have all three
88 has_withq = any((name + '_WITH_' + queue in all_states)
89 for queue in ('METAQ', 'CONTQ', 'BOTHQ'))
90 if has_withq:
91 for queue in ('METAQ', 'CONTQ', 'BOTHQ'):
92 other_name = name + '_WITH_' + queue
93 if other_name not in all_states:
94 print name, 'has some queues but not', queue
95 else:
96 other = all_states[other_name]
97 this_trn = set(state.transitions)
98 other_trn = set(other.transitions)
99 if this_trn != other_trn:
100 only_in_this = this_trn - other_trn
101 only_in_other = other_trn - this_trn
102 if only_in_this:
103 print 'missing from %s: %s' % \
104 (other_name, ", ".join(sorted(only_in_this)))
105 if only_in_other:
106 print 'missing from %s: %s' % \
107 (name, ", ".join(sorted(only_in_other)))
108 # the tuple is SYS_META_QUEUE_WAITING, _DONE, and then _CONTENT_
109 ok_trns = {'meta': ('meta', '', 'both', 'meta'),
110 'cont': ('both', 'cont', 'cont', ''),
111 'both': ('both', 'cont', 'both', 'meta'),
112 '': ('meta', '', 'cont', ''),
113 }
114 if has_q(state.name):
115 this_q = filter(None, has_q(state.name).groups())[0].lower()
116 else:
117 this_q = ''
118 for i, evt in enumerate(['SYS_META_QUEUE_WAITING',
119 'SYS_META_QUEUE_DONE',
120 'SYS_CONTENT_QUEUE_WAITING',
121 'SYS_CONTENT_QUEUE_DONE']):
122 trn = state.transitions.get(evt, None)
123 if trn is None:
124 continue
125 if has_q(trn):
126 that_q = filter(None, has_q(trn).groups())[0].lower()
127 else:
128 that_q = ''
129 if ok_trns[this_q][i] != that_q:
130 print '%s goes to %r on %r instead of %r' % (state.name,
131 trn, evt,
132 ok_trns[this_q][i])
133
134 # most states should handle the queue events
135 if not (isinstance(state, states.AQErrorState)
136 or name == 'INIT'
137 or name.startswith('INIT_')):
138 for event in ['SYS_META_QUEUE_WAITING', 'SYS_META_QUEUE_DONE',
139 'SYS_CONTENT_QUEUE_WAITING', 'SYS_CONTENT_QUEUE_DONE']:
140 if event not in state.transitions:
141 print name, 'does not handle', event
142
1430
=== modified file 'tests/syncdaemon/test_main.py'
--- tests/syncdaemon/test_main.py 2009-09-01 20:35:36 +0000
+++ tests/syncdaemon/test_main.py 2009-10-07 07:30:24 +0000
@@ -118,6 +118,7 @@
118 reactor.callLater(0, d0.callback, None)118 reactor.callLater(0, d0.callback, None)
119119
120 main = self.build_main(handshake_timeout=.5)120 main = self.build_main(handshake_timeout=.5)
121 main.action_q.connect = lambda *_: defer.Deferred()
121 main.event_q.subscribe(handler)122 main.event_q.subscribe(handler)
122 d = main.start()123 d = main.start()
123 d.addCallback(lambda _: main.event_q.push('SYS_NET_CONNECTED'))124 d.addCallback(lambda _: main.event_q.push('SYS_NET_CONNECTED'))
@@ -154,11 +155,13 @@
154 if the state is ok, pass the test155 if the state is ok, pass the test
155 """156 """
156 if main.state.name != 'EXCESSIVE_TIMEOUTS':157 if main.state.name != 'EXCESSIVE_TIMEOUTS':
157 d0.errback(Exception('Too many timeouts'))158 d0.errback(Exception('Too many timeouts: %d'
159 % cls.num_timeouts))
158 else:160 else:
159 d0.callback('OK!')161 d0.callback('OK!')
160162
161 main = self.build_main(handshake_timeout=.1)163 main = self.build_main(handshake_timeout=.1)
164 main.action_q.connect = lambda *_: defer.Deferred()
162 main.event_q.subscribe(handler)165 main.event_q.subscribe(handler)
163 d = main.start()166 d = main.start()
164 d.addCallback(lambda _: main.event_q.push('SYS_NET_CONNECTED'))167 d.addCallback(lambda _: main.event_q.push('SYS_NET_CONNECTED'))
165168
=== added file 'tests/syncdaemon/test_states.py'
--- tests/syncdaemon/test_states.py 1970-01-01 00:00:00 +0000
+++ tests/syncdaemon/test_states.py 2009-10-07 07:30:24 +0000
@@ -0,0 +1,571 @@
1"""
2Sanity checks for the humongous ball of dragonspit that is
3ubuntuone.syncdaemon.states
4"""
5import re
6import unittest
7from ubuntuone.syncdaemon import states, event_queue
8
9
10all_states = dict((k, v) for (k, v) in vars(states).items()
11 if isinstance(v, states.SyncDaemonState))
12all_trns = set(sum((state.transitions.values()
13 for state in all_states.values()), []))
14
15has_q = re.compile(r'.*_WITH_([^_]+Q)$').search
16
17class TestBasic(unittest.TestCase):
18 """
19 Checks that apply to (nearly) all states
20 """
21 def test_name(self):
22 """
23 Check that the object's name is the same as the name of the object
24 """
25 self.assertEqual(self.name, self.state.name)
26
27 def _test_handle_external_events(self, external_event):
28 """
29 Generic check, that the given external event is handled in some way
30 """
31 self.assertTrue(external_event in self.state.transitions,
32 "unhandled external event: %s" % external_event)
33
34 def test_handle_sys_net_disconnected(self):
35 """
36 Check SYS_NET_DISCONNECTED is handled
37 """
38 self._test_handle_external_events('SYS_NET_DISCONNECTED')
39
40 def test_handle_sys_net_connected(self):
41 """
42 Check SYS_NET_CONNECTED is handled
43 """
44 self._test_handle_external_events('SYS_NET_CONNECTED')
45
46 def test_handle_sys_connect(self):
47 """
48 Check SYS_CONNECT is handled
49 """
50 self._test_handle_external_events('SYS_CONNECT')
51
52 def test_handle_sys_disconnect(self):
53 """
54 Check SYS_DISCONNECT is handled
55 """
56 self._test_handle_external_events('SYS_DISCONNECT')
57
58 def test_handle_sys_connection_lost(self):
59 """
60 Check SYS_CONNECTION_LOST is handled
61 """
62 self._test_handle_external_events('SYS_CONNECTION_LOST')
63
64 def test_reachable(self):
65 """
66 Check the state is reachable via a transition
67 """
68 self.assertTrue(self.name in all_trns,
69 "%s is not the target of any transition!" % self.name)
70
71 def test_start_connecting(self):
72 """
73 Check START_CONNECTING is only reached via SYS_CONNECTION_LOST
74 or one of the READY states
75 """
76 for evt, trn in self.state.transitions.items():
77 if ((trn.startswith('START_CONNECTING')
78 and not (evt == 'SYS_CONNECTION_LOST'
79 or 'WITH_CONNECTION_LOST' in self.name))
80 and not
81 ((self.name.startswith('READY_WAITING')
82 and evt == 'SYS_NET_CONNECTED')
83 or (self.name.startswith('READY_WITH_NETWORK')
84 and evt == 'SYS_CONNECT')
85 or (self.name.startswith('READING_WAITING_WITH_NETWORK')
86 and evt == 'SYS_LOCAL_RESCAN_DONE'))):
87 raise AssertionError('%s --[%s]--> %s, not STANDOFFish'
88 % (self.name, evt, trn))
89
90 def test_events_exist(self):
91 """
92 Check the events are known to EventQueue
93 """
94 diff = set(self.state.transitions) - set(event_queue.EVENTS)
95 self.assertFalse(diff, "unknown events: %s" % ", ".join(diff))
96
97 def test_transitions_exist(self):
98 """
99 Check the target states are known
100 """
101 diff = set(self.state.transitions.values()) - set(all_states)
102 self.assertFalse(diff, "unknown transitions: %s" % ", ".join(diff))
103
104 def test_enter_only_on_start(self):
105 """
106 Only START_ states (and UNKNOWN_ERROR) should have an enter function
107 """
108 if self.name != 'UNKNOWN_ERROR':
109 if not self.name.startswith('START_'):
110 if self.state.enter is not None:
111 raise AssertionError("%s has enter" % self.name)
112
113 def _test_withq_evt_ok(self, evt, exceptions):
114 """
115 Generic check that the different WITH_xxxQ states are sane
116
117 'sane' here means that they follow the general pattern (seen
118 in ok_trns), i.e. that the different queue events move the
119 state correctly. There are exceptions, which can be specified.
120 """
121 if evt not in self.state.transitions:
122 return
123
124 trn = self.state.transitions[evt]
125
126 if has_q(self.name):
127 this_q = filter(None, has_q(self.name).groups())[0].lower()
128 else:
129 this_q = ''
130
131 ok_trns = {'metaq': {'SYS_CONTENT_QUEUE_DONE': 'metaq',
132 'SYS_CONTENT_QUEUE_WAITING': 'bothq',
133 'SYS_META_QUEUE_DONE': '',
134 'SYS_META_QUEUE_WAITING': 'metaq'},
135 'contq': {'SYS_CONTENT_QUEUE_DONE': '',
136 'SYS_CONTENT_QUEUE_WAITING': 'contq',
137 'SYS_META_QUEUE_DONE': 'contq',
138 'SYS_META_QUEUE_WAITING': 'bothq'},
139 'bothq': {'SYS_CONTENT_QUEUE_DONE': 'metaq',
140 'SYS_CONTENT_QUEUE_WAITING': 'bothq',
141 'SYS_META_QUEUE_DONE': 'contq',
142 'SYS_META_QUEUE_WAITING': 'bothq'},
143 '': {'SYS_CONTENT_QUEUE_DONE': '',
144 'SYS_CONTENT_QUEUE_WAITING': 'contq',
145 'SYS_META_QUEUE_DONE': '',
146 'SYS_META_QUEUE_WAITING': 'metaq'},
147 }
148
149 if has_q(trn):
150 that_q = filter(None, has_q(trn).groups())[0].lower()
151 else:
152 that_q = ''
153 if ok_trns[this_q][evt] != that_q:
154 # a few exceptions exist
155 if (self.name, trn) not in exceptions:
156 raise AssertionError('%s --[%s]--> %s instead of %s'
157 % (self.name, evt, trn,
158 ok_trns[this_q][evt]))
159 def test_metaq_waiting_evt_ok(self):
160 """
161 Check for correct handling of SYS_META_QUEUE_WAITING
162 """
163 self._test_withq_evt_ok(
164 'SYS_META_QUEUE_WAITING',
165 [('IDLE', 'START_WORKING_ON_METADATA'),
166 ('START_WORKING_ON_BOTH', 'WORKING_ON_BOTH'),
167 ('START_WORKING_ON_CONTENT', 'START_WORKING_ON_BOTH'),
168 ('START_WORKING_ON_METADATA_WITH_CONTQ',
169 'WORKING_ON_METADATA_WITH_CONTQ'),
170 ('START_WORKING_ON_METADATA', 'WORKING_ON_METADATA'),
171 ('WORKING_ON_BOTH', 'WORKING_ON_BOTH'),
172 ('WORKING_ON_CONTENT', 'START_WORKING_ON_BOTH'),
173 ('WORKING_ON_METADATA_WITH_CONTQ',
174 'WORKING_ON_METADATA_WITH_CONTQ'),
175 ('WORKING_ON_METADATA', 'WORKING_ON_METADATA'),
176 ])
177
178 def test_metaq_done_evt_ok(self):
179 """
180 Check for correct handling of SYS_META_QUEUE_DONE
181 """
182 self._test_withq_evt_ok(
183 'SYS_META_QUEUE_DONE',
184 [('START_WORKING_ON_METADATA_WITH_CONTQ',
185 'START_WORKING_ON_CONTENT'),
186 ('WORKING_ON_METADATA_WITH_CONTQ', 'START_WORKING_ON_CONTENT'),
187 ])
188
189 def test_contq_waiting_ok(self):
190 """
191 Check for correct handling of SYS_CONTENT_QUEUE_WAITING
192 """
193 self._test_withq_evt_ok(
194 'SYS_CONTENT_QUEUE_WAITING',
195 [('IDLE', 'START_WORKING_ON_CONTENT'),
196 ('START_WORKING_ON_BOTH', 'WORKING_ON_BOTH'),
197 ('START_WORKING_ON_CONTENT', 'WORKING_ON_CONTENT'),
198 ('WORKING_ON_BOTH', 'WORKING_ON_BOTH'),
199 ('WORKING_ON_CONTENT', 'WORKING_ON_CONTENT'),
200 ])
201
202 def test_contq_done_ok(self):
203 """
204 Check for correct handling of SYS_CONTENT_QUEUE_DONE
205 """
206 self._test_withq_evt_ok('SYS_CONTENT_QUEUE_DONE', [])
207
208 def test_non_network_transition_leaves_network_alone(self):
209 """
210 Check that the non-network events affect the network state
211
212 network events are SYS_NET_CONNECTED and SYS_NET_DISCONNECTED
213 """
214 bad = []
215 tpl = "%s.has_network is %s but -[%s]->%s.has_network is %s"
216 for evt, trn in self.state.transitions.items():
217 if evt in ('SYS_NET_CONNECTED', 'SYS_NET_DISCONNECTED'):
218 continue
219 trn = all_states[trn]
220 if self.state.has_network != trn.has_network and not trn.is_error:
221 bad.append(tpl % (self.state.name,
222 self.state.has_network,
223 evt, trn.name,
224 trn.has_network))
225 self.assertFalse(bad, ";\n".join(bad))
226
227 def test_network_transition_changes_network_state(self):
228 """
229 Check that network events affect the network state
230 """
231 connected = self.state.transitions['SYS_NET_CONNECTED']
232 disconnected = self.state.transitions['SYS_NET_DISCONNECTED']
233 if not self.state.is_error:
234 self.assertTrue(all_states[connected].has_network)
235 else:
236 self.assertFalse(all_states[connected].has_network)
237 self.assertFalse(all_states[disconnected].has_network)
238
239 def test_non_volitional_transition_leaves_volition_alone(self):
240 """
241 Check that non-volitional events leave the volition alone
242
243 Volitional events are SYS_CONNECT and SYS_DISCONNECT
244 """
245 bad = []
246 tpl = "%s.wants_to_connect is %s but -[%s]->%s.wants_to_connect is %s"
247 for evt, trn in self.state.transitions.items():
248 if evt in ('SYS_CONNECT', 'SYS_DISCONNECT'):
249 continue
250 trn = all_states[trn]
251 if self.state.wants_to_connect != trn.wants_to_connect and not trn.is_error:
252 bad.append(tpl % (self.state.name,
253 self.state.wants_to_connect,
254 evt, trn.name,
255 trn.wants_to_connect))
256 self.assertFalse(bad, ";\n".join(bad))
257
258
259class TestWithQ:
260 """
261 Checks for states with a given with_q
262 """
263 def get_thisq(self):
264 """
265 Get the queue of the current state (from the state's name)
266 """
267 m = has_q(self.state.name)
268 if m is None:
269 return None
270 return filter(None, m.groups())[0]
271
272 def test_withq(self):
273 """
274 Test the queue specified via with_q and the state's name match
275 """
276 if self.state.with_q is None and has_q(self.name):
277 raise AssertionError('%s should have with_q %s, has None'
278 % (self.name, self.get_thisq()))
279 elif self.state.with_q != self.get_thisq():
280 raise AssertionError("%s's name imples with_q %s, has %s"
281 % (self.name, self.get_thisq(),
282 self.state.with_q))
283
284 def test_another_withq(self):
285 """
286 Test that states with one of the with_q's have the others.
287
288 Some exceptions exist.
289 """
290 this_q = self.get_thisq() or ''
291 is_ok = ((this_q == '' and self.state.with_q is None)
292 or (this_q.upper() == self.state.with_q))
293 if not is_ok:
294 if (self.name, this_q, self.state.with_q) not in [
295 ('START_WORKING_ON_CONTENT', 'cont', None),
296 ('START_WORKING_ON_METADATA', 'meta', None),
297 ('WORKING_ON_CONTENT', 'cont', None),
298 ('WORKING_ON_METADATA', 'meta', None),
299 ]:
300 raise AssertionError(
301 "%s's name implies %s, but attribute is %r"
302 % (self.name, this_q or 'noQ', self.state.with_q))
303
304
305class TestCleanupWithConnectionLost:
306 """
307 Checks for CLEANUP states that have already seen SYS_CONNECTION_LOST
308 """
309 def test_cleanup_with_connection_lost(self):
310 """
311 CLEANUP_WITH_CONNECTION_LOST states have already gotten their
312 CONNECTION_LOST, so they don't need to wait for it; they need
313 to not wait for it, instead.
314 """
315 if self.name.startswith('START_'):
316 name = self.name[6:]
317 else:
318 name = self.name
319 target = self.state.transitions['SYS_CONNECTION_LOST']
320 self.assertEqual(name, target)
321
322class TestCleanupPlain:
323 """
324 Tests for CLEANUP states that have not yet seen SYS_CONNECTION_LOST
325 """
326 def test_cleanup_plain_on_connection_lost(self):
327 """
328 When the CONNECTION_LOST events come in, "plain" cleanup states
329 need to go to the sibling CLEANUP_WITH_CONNECTION_LOST
330 """
331 evt = 'SYS_CONNECTION_LOST'
332 trn = self.state.transitions[evt]
333 expected = self.name
334 # start transitions don't transition to self
335 expected = re.sub(r'^START_', '', expected)
336 expected = re.sub(r'^CONNECTED_CLEANUP',
337 'CLEANUP_WITH_NETWORK', expected)
338 expected = re.sub(r'(.*?)((?:_WITH_(?:CONT|META|BOTH)Q)?)$',
339 r'\1_WITH_CONNECTION_LOST\2',
340 expected)
341 self.assertEqual(trn, expected,
342 '%s --[%s]--> %s, should be %s'
343 % (self.name, evt, trn, expected))
344
345class TestCleanupNonStarter:
346 """
347 Test for CLEANUP states that are not START_ states
348 """
349 def test_cleanup_on_cleanup_done(self):
350 """
351 Test non-START_ CLEANUP states handle SYS_CLEANUP_FINISHED
352 appropriately
353 """
354 self.assertTrue('SYS_CLEANUP_FINISHED' in self.state.transitions,
355 '%s should handle SYS_CLEANUP_FINISHED' % self.name)
356 evt = 'SYS_CLEANUP_FINISHED'
357 trn = self.state.transitions[evt]
358 self.assertTrue(trn.startswith('START_STANDOFF'),
359 '%s --[%s]--> %s, should be START_STANDOFFish'
360 % (self.name, evt, trn))
361
362class TestStarter:
363 """
364 Tests for START_ states
365 """
366 def setUp(self):
367 """
368 Common set-up code
369 """
370 self.other_name = re.sub(r'^START_', '', self.name)
371 self.other = all_states.get(self.other_name, None)
372 if self.other is not None:
373 self.this_trn = set(self.state.transitions)
374 self.other_trn = set(self.other.transitions)
375 self.only_in_this = self.this_trn - self.other_trn
376 self.only_in_other = self.other_trn - self.this_trn \
377 - set(['SYS_SERVER_RESCAN_DONE', 'SYS_CLEANUP_FINISHED'])
378
379 def test_starters_have_enter(self):
380 """
381 All START_ states should have an enter function
382 """
383 self.assertTrue(self.state.enter is not None,
384 '%s should have an enter function' % self.name)
385
386 def test_other_exists(self):
387 """
388 All START_ states should have a non-START_ state
389 """
390 self.assertTrue(self.other_name in all_states,
391 '%s has no non-starter' % self.name)
392
393 def test_no_events_only_in_this(self):
394 """
395 All START_ states need to handle the same events as their
396 non-START_ counterparts
397 """
398 if self.other is None:
399 raise AssertionError('missing non-starter, unable to test')
400 self.assertFalse(
401 self.only_in_this,
402 # an event in the START state is not handled by the non-START
403 'missing from %s: %s' % (self.other_name,
404 ", ".join(sorted(self.only_in_this))))
405
406 def test_no_events_only_in_other(self):
407 """
408 in general, non-START_ states need to handle the same events
409 as their START_ counterparts
410 """
411 if self.other is None:
412 raise AssertionError('missing non-starter, unable to test')
413 self.assertFalse(
414 self.only_in_other,
415 'missing from %s: %s' % (self.name,
416 ", ".join(sorted(self.only_in_other))))
417
418 def test_same_transitions(self):
419 """
420 in general, the transition dict for START_ and non-START_
421 states should be the same
422 """
423 if self.other is None:
424 raise AssertionError('missing non-starter, unable to test')
425 bad = ['%s pushes %s --> %s, but %s --> %s'
426 % (trn, self.name, self.state.transitions[trn],
427 self.other.name, self.other.transitions[trn])
428 for trn in sorted(self.this_trn.intersection(self.other_trn))
429 if (self.state.transitions[trn] != self.other.transitions[trn]
430 and not (self.name == self.state.transitions[trn] and
431 self.other.name == self.other.transitions[trn]))]
432 self.assertFalse(bad, bad)
433
434
435class TestOtherQ:
436 """
437 Test for states that have _WITH_fooQ states
438 """
439 def _test_other_queues(self, queue, exceptions):
440 """
441 Check that a WITH_fooQ state exists for the given queue (with
442 the given exceptions). Further, check that if it does indeed
443 exist, it handles the same transitions.
444 """
445 other_name = self.name + '_WITH_' + queue
446 if other_name not in all_states:
447 if self.name not in exceptions:
448 raise AssertionError('%s has some queues but not %s'
449 % (self.name, queue))
450 else:
451 other = all_states[other_name]
452 this_trn = set(self.state.transitions)
453 other_trn = set(other.transitions)
454 if this_trn != other_trn:
455 only_in_this = this_trn - other_trn
456 only_in_other = other_trn - this_trn
457 if only_in_this:
458 raise AssertionError('missing from %s: %s' %
459 (other_name,
460 ", ".join(sorted(only_in_this))))
461 if only_in_other:
462 raise AssertionError('missing from %s: %s' %
463 (self.name,
464 ", ".join(sorted(only_in_other))))
465
466 def test_other_meta_queue(self):
467 """
468 Check that a WITH_METAQ state exists for the current state
469 (with exceptions). Further, check that if it does indeed
470 exist, it handles the same transitions as the base state.
471 """
472 self._test_other_queues('METAQ', [
473 'START_CLEANUP_WAITING',
474 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
475 'START_CONNECTED_CLEANUP',
476 'START_WORKING_ON_METADATA',
477 'WORKING_ON_METADATA',
478 ])
479
480 def test_other_cont_queue(self):
481 """
482 Check that a WITH_CONTQ state exists for the current state
483 (with exceptions). Further, check that if it does indeed
484 exist, it handles the same transitions as the base state.
485 """
486 self._test_other_queues('CONTQ', [])
487
488 def test_other_both_queue(self):
489 """
490 Check that a WITH_BOTHQ state exists for the current state
491 (with exceptions). Further, check that if it does indeed
492 exist, it handles the same transitions as the base state.
493 """
494 self._test_other_queues('BOTHQ', [
495 'START_CLEANUP_WAITING',
496 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
497 'START_CONNECTED_CLEANUP',
498 'START_WORKING_ON_METADATA',
499 'WORKING_ON_METADATA',
500 ])
501
502
503class TestHandleQueues:
504 """
505 Tests for handling of queue events
506 """
507 def _test_handles_queue_event(self, queue_event):
508 """
509 Generic test that the current state handles the given queue event
510 """
511 self.assertTrue(queue_event in self.state.transitions,
512 self.name + ' does not handle ' + queue_event)
513
514 def test_handles_meta_queue_waiting(self):
515 """
516 Check SYS_META_QUEUE_WAITING is handled
517 """
518 self._test_handles_queue_event('SYS_META_QUEUE_WAITING')
519
520 def test_handles_content_queue_waiting(self):
521 """
522 Check SYS_CONTENT_QUEUE_WAITING is handled
523 """
524 self._test_handles_queue_event('SYS_CONTENT_QUEUE_WAITING')
525
526 def test_handles_meta_queue_done(self):
527 """
528 Check SYS_META_QUEUE_DONE is handled
529 """
530 self._test_handles_queue_event('SYS_META_QUEUE_DONE')
531
532 def test_handles_content_queue_done(self):
533 """
534 Check SYS_CONTENT_QUEUE_DONE is handled
535 """
536 self._test_handles_queue_event('SYS_CONTENT_QUEUE_DONE')
537
538
539def test_suite():
540 """
541 Build the test suite
542 """
543 suite = unittest.TestSuite()
544 loader = unittest.TestLoader()
545 flag = object()
546 for name, state in all_states.items():
547 bases = [TestBasic]
548 if getattr(state, 'with_q', flag) is not flag:
549 bases.append(TestWithQ)
550 if re.search('CLEANUP.*WITH_CONNECTION_LOST', name):
551 bases.append(TestCleanupWithConnectionLost)
552 elif 'CLEANUP' in name:
553 bases.append(TestCleanupPlain)
554 if name.startswith('CLEANUP'):
555 bases.append(TestCleanupNonStarter)
556 if name.startswith('START_'):
557 if not name.startswith('START_CONNECTED_CLEANUP'):
558 # CONNECTED_CLEANUP doesn't exist;
559 # we fake it with CLEANUP_WITH_NETWORK
560 bases.append(TestStarter)
561 if any((name + '_WITH_' + queue in all_states)
562 for queue in ('METAQ', 'CONTQ', 'BOTHQ')):
563 bases.append(TestOtherQ)
564 if not (isinstance(state, states.AQErrorState)
565 or name == 'INIT'
566 or name.startswith('INIT_')):
567 bases.append(TestHandleQueues)
568 bases = tuple(reversed(bases))
569 test = type('Test_'+name, bases, {'name': name, 'state': state})
570 suite.addTest(loader.loadTestsFromTestCase(test))
571 return suite
0572
=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py 2009-09-18 18:41:10 +0000
+++ ubuntuone/syncdaemon/action_queue.py 2009-10-07 07:30:24 +0000
@@ -183,12 +183,16 @@
183 """183 """
184 connection_state = 'disconnected'184 connection_state = 'disconnected'
185 factory = None185 factory = None
186 _finished = False
186187
187 def connectionMade(self):188 def connectionMade(self):
188 """189 """
189 Called when a new connection is made.190 Called when a new connection is made.
190 All the state is saved in the factory.191 All the state is saved in the factory.
191 """192 """
193 if self._finished:
194 # the factory is no longer interested in what we have to say
195 return
192 logger.debug("connection made")196 logger.debug("connection made")
193 LoggingStorageClient.connectionMade(self)197 LoggingStorageClient.connectionMade(self)
194 self.connection_state = 'connected'198 self.connection_state = 'connected'
@@ -204,9 +208,13 @@
204 """208 """
205 Close down the sockets209 Close down the sockets
206 """210 """
211 self._finished = True
207 logger.debug("disconnected")212 logger.debug("disconnected")
208 if self.transport is not None:213 if self.transport is not None:
209 self.transport.loseConnection()214 self.transport.loseConnection()
215 else:
216 # fake the event
217 self.factory.connectionLost(self, 'Transport is None')
210218
211 def connectionLost(self, reason=None):219 def connectionLost(self, reason=None):
212 """220 """
@@ -873,6 +881,9 @@
873 if self.client is not None:881 if self.client is not None:
874 self.client.disconnect()882 self.client.disconnect()
875 self.client = None883 self.client = None
884 else:
885 # fake it
886 self.connectionLost(None, 'client is None')
876887
877 def conectionFailed(self, reason=None):888 def conectionFailed(self, reason=None):
878 """889 """
879890
=== modified file 'ubuntuone/syncdaemon/state.py'
--- ubuntuone/syncdaemon/state.py 2009-08-28 20:46:35 +0000
+++ ubuntuone/syncdaemon/state.py 2009-10-07 07:30:24 +0000
@@ -95,7 +95,6 @@
95 """95 """
96 self.watchdog = None96 self.watchdog = None
97 self.num_timeouts += 197 self.num_timeouts += 1
98 self.main.action_q.disconnect()
99 self.main.event_q.push('SYS_HANDSHAKE_TIMEOUT')98 self.main.event_q.push('SYS_HANDSHAKE_TIMEOUT')
10099
101 @property100 @property
102101
=== modified file 'ubuntuone/syncdaemon/states.py'
--- ubuntuone/syncdaemon/states.py 2009-08-13 14:49:48 +0000
+++ ubuntuone/syncdaemon/states.py 2009-10-07 07:30:24 +0000
@@ -19,6 +19,24 @@
19The states of the SyncDaemon19The states of the SyncDaemon
20"""20"""
2121
22from pprint import pformat
23from inspect import getsource
24from difflib import unified_diff
25
26def compare(this, that):
27 this = vars(this)
28 if this['enter'] is not None:
29 this['enter'] = getsource(this['enter']).strip()
30 that = vars(that)
31 if that['enter'] is not None:
32 that['enter'] = getsource(that['enter']).strip()
33 if this != that:
34 print "\n".join(unified_diff(pformat(this).split('\n'),
35 pformat(that).split('\n'),
36 'new '+this['name'], 'old'))
37 assert False
38
39
22class BadTransition(Exception):40class BadTransition(Exception):
23 """41 """
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.
@@ -50,6 +68,13 @@
50 self.is_connected = is_connected68 self.is_connected = is_connected
51 self.is_online = is_online69 self.is_online = is_online
52 self.enter = enter70 self.enter = enter
71 self.has_network = any((self.is_connected,
72 "WITH_NETWORK" in name,
73 "CONNECTING" in name,
74 "CONNECTED_CLEANUP" in name))
75 self.wants_to_connect = any((self.is_connected,
76 "WAITING" in name,
77 "CONNECTING" in name))
53 self.is_handshake = 'SYS_HANDSHAKE_TIMEOUT' in other_transitions78 self.is_handshake = 'SYS_HANDSHAKE_TIMEOUT' in other_transitions
54 self.transitions = dict(SYS_NET_CONNECTED=sys_net_connected_trn,79 self.transitions = dict(SYS_NET_CONNECTED=sys_net_connected_trn,
55 SYS_CONNECT=sys_connect_trn,80 SYS_CONNECT=sys_connect_trn,
@@ -74,6 +99,81 @@
74 raise BadTransition("State %s can't handle the %s event"99 raise BadTransition("State %s can't handle the %s event"
75 % (self.name, event))100 % (self.name, event))
76101
102
103 def clone_with_queue(self, qname, **extra_transitions):
104 new_trns = self.transitions.copy()
105 del new_trns['SYS_UNKNOWN_ERROR']
106 suffix = '_WITH_' + qname
107 mqw_trn = new_trns.pop('SYS_META_QUEUE_WAITING')
108 mqd_trn = new_trns.pop('SYS_META_QUEUE_DONE')
109 cqw_trn = new_trns.pop('SYS_CONTENT_QUEUE_WAITING')
110 cqd_trn = new_trns.pop('SYS_CONTENT_QUEUE_DONE')
111 if self.name.startswith('START_'):
112 bq_trn = self.name[6:] + '_WITH_BOTHQ'
113 expected_name = 'START_' + dict(METAQ=mqw_trn,
114 CONTQ=cqw_trn, BOTHQ=bq_trn)[qname]
115 else:
116 bq_trn = self.name + '_WITH_BOTHQ'
117 expected_name = dict(METAQ=mqw_trn,
118 CONTQ=cqw_trn, BOTHQ=bq_trn)[qname]
119 mqw = dict(METAQ=mqw_trn, CONTQ=bq_trn, BOTHQ=bq_trn)[qname]
120 mqd = dict(METAQ=mqd_trn, CONTQ=cqw_trn, BOTHQ=cqw_trn)[qname]
121 cqw = dict(METAQ=bq_trn, CONTQ=cqw_trn, BOTHQ=bq_trn)[qname]
122 cqd = dict(METAQ=mqw_trn, CONTQ=cqd_trn, BOTHQ=mqw_trn)[qname]
123 new = SyncDaemonState(self.name + suffix,
124 self.description + ', ' + qname + ' waiting',
125 new_trns.pop('SYS_NET_CONNECTED') + suffix,
126 new_trns.pop('SYS_CONNECT') + suffix,
127 new_trns.pop('SYS_NET_DISCONNECTED') + suffix,
128 new_trns.pop('SYS_DISCONNECT') + suffix,
129 new_trns.pop('SYS_CONNECTION_LOST') + suffix,
130 self.is_error, self.is_connected, self.is_online,
131 self.enter,
132 SYS_META_QUEUE_WAITING=mqw,
133 SYS_META_QUEUE_DONE=mqd,
134 SYS_CONTENT_QUEUE_WAITING=cqw,
135 SYS_CONTENT_QUEUE_DONE=cqd)
136 new.is_handshake = self.is_handshake
137 new.with_q = qname
138 assert new.name == expected_name, "%r != %r" % (new.name, expected_name)
139 for evt, trn in new_trns.items():
140 if trn not in ['BAD_VERSION', 'CAPABILITIES_MISMATCH', 'AUTH_FAILED']:
141 trn = trn + suffix
142 new.transitions[evt] = trn
143 for evt, trn in extra_transitions.items():
144 new.transitions[evt] = trn
145 return new
146
147 def clone_with_metaq(self, **extra_transitions):
148 return self.clone_with_queue('METAQ', **extra_transitions)
149
150 def clone_with_contq(self, **extra_transitions):
151 return self.clone_with_queue('CONTQ', **extra_transitions)
152
153 def clone_with_bothq(self, **extra_transitions):
154 return self.clone_with_queue('BOTHQ', **extra_transitions)
155
156 def clone_with_no_start(self, new_description, **extra_transitions):
157 if not self.name.startswith('START_'):
158 raise ValueError, "Not a START_ transition"
159 name = self.name[6:]
160 new_trns = self.transitions.copy()
161 del new_trns['SYS_UNKNOWN_ERROR']
162 new_trns.update(extra_transitions)
163 new = SyncDaemonState(name,
164 new_description,
165 new_trns.pop('SYS_NET_CONNECTED'),
166 new_trns.pop('SYS_CONNECT'),
167 new_trns.pop('SYS_NET_DISCONNECTED'),
168 new_trns.pop('SYS_DISCONNECT'),
169 new_trns.pop('SYS_CONNECTION_LOST'),
170 self.is_error, self.is_connected, self.is_online,
171 None,
172 **new_trns)
173 if getattr(self, 'with_q', object) is not object:
174 new.with_q = self.with_q
175 return new
176
77class NonActiveConnectedSDState(SyncDaemonState):177class NonActiveConnectedSDState(SyncDaemonState):
78 """178 """
79 States that handle network disconnections with no cleanup179 States that handle network disconnections with no cleanup
@@ -84,6 +184,7 @@
84 ready_waiting = 'READY_WAITING'184 ready_waiting = 'READY_WAITING'
85 ready_w_network = 'READY_WITH_NETWORK'185 ready_w_network = 'READY_WITH_NETWORK'
86 start_connecting = 'START_CONNECTING'186 start_connecting = 'START_CONNECTING'
187 self.with_q = with_q
87 if with_q is not None:188 if with_q is not None:
88 ready_waiting += '_WITH_' + with_q189 ready_waiting += '_WITH_' + with_q
89 ready_w_network += '_WITH_' + with_q190 ready_w_network += '_WITH_' + with_q
@@ -111,11 +212,15 @@
111 suffix = '_WITH_' + with_q212 suffix = '_WITH_' + with_q
112 else:213 else:
113 suffix = ''214 suffix = ''
215 if name.startswith('START_'):
216 next_name = name[6:]
217 else:
218 next_name = name
114 super(WorkingSDState, self).__init__(219 super(WorkingSDState, self).__init__(
115 name, description, name, name,220 name, description, next_name, next_name,
116 'START_CLEANUP_WAITING' + suffix,221 'START_CLEANUP_WAITING' + suffix,
117 'START_CONNECTED_CLEANUP' + suffix,222 'START_CONNECTED_CLEANUP' + suffix,
118 'START_CLEANUP_WAITING_WITH_NETWORK' + suffix,223 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST' + suffix,
119 is_connected=True, is_online=True,224 is_connected=True, is_online=True,
120 **other_transitions)225 **other_transitions)
121226
@@ -177,42 +282,9 @@
177 SYS_CONTENT_QUEUE_WAITING='READING_WITH_CONTQ',282 SYS_CONTENT_QUEUE_WAITING='READING_WITH_CONTQ',
178 SYS_CONTENT_QUEUE_DONE='READING',283 SYS_CONTENT_QUEUE_DONE='READING',
179 )284 )
180285READING_WITH_METAQ = READING.clone_with_metaq()
181READING_WITH_METAQ = SyncDaemonState(286READING_WITH_CONTQ = READING.clone_with_contq()
182 'READING_WITH_METAQ',287READING_WITH_BOTHQ = READING.clone_with_bothq()
183 'doing local rescan, meta_q waiting',
184 'READING_WITH_NETWORK_WITH_METAQ', 'READING_WAITING_WITH_METAQ',
185 'READING_WITH_METAQ', 'READING_WITH_METAQ', 'READING_WITH_METAQ',
186 SYS_LOCAL_RESCAN_DONE='READY_FOR_NETWORK_WITH_METAQ',
187 SYS_META_QUEUE_WAITING='READING_WITH_METAQ',
188 SYS_META_QUEUE_DONE='READING',
189 SYS_CONTENT_QUEUE_WAITING='READING_WITH_BOTHQ',
190 SYS_CONTENT_QUEUE_DONE='READING_WITH_METAQ',
191 )
192
193READING_WITH_CONTQ = SyncDaemonState(
194 'READING_WITH_CONTQ',
195 'doing local rescan, content_q waiting',
196 'READING_WITH_NETWORK_WITH_CONTQ', 'READING_WAITING_WITH_CONTQ',
197 'READING_WITH_CONTQ', 'READING_WITH_CONTQ', 'READING_WITH_CONTQ',
198 SYS_LOCAL_RESCAN_DONE='READY_FOR_NETWORK_WITH_CONTQ',
199 SYS_META_QUEUE_WAITING='READING_WITH_BOTHQ',
200 SYS_META_QUEUE_DONE='READING_WITH_CONTQ',
201 SYS_CONTENT_QUEUE_WAITING='READING_WITH_CONTQ',
202 SYS_CONTENT_QUEUE_DONE='READING',
203 )
204
205READING_WITH_BOTHQ = SyncDaemonState(
206 'READING_WITH_BOTHQ',
207 'doing local rescan, both _q\'s waiting',
208 'READING_WITH_NETWORK_WITH_BOTHQ', 'READING_WAITING_WITH_BOTHQ',
209 'READING_WITH_BOTHQ', 'READING_WITH_BOTHQ', 'READING_WITH_BOTHQ',
210 SYS_LOCAL_RESCAN_DONE='READY_FOR_NETWORK_WITH_BOTHQ',
211 SYS_META_QUEUE_WAITING='READING_WITH_BOTHQ',
212 SYS_META_QUEUE_DONE='READING_WITH_CONTQ',
213 SYS_CONTENT_QUEUE_WAITING='READING_WITH_BOTHQ',
214 SYS_CONTENT_QUEUE_DONE='READING_WITH_METAQ',
215 )
216288
217READING_WITH_NETWORK = SyncDaemonState(289READING_WITH_NETWORK = SyncDaemonState(
218 'READING_WITH_NETWORK',290 'READING_WITH_NETWORK',
@@ -225,48 +297,9 @@
225 SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_CONTQ',297 SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_CONTQ',
226 SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK',298 SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK',
227 )299 )
228300READING_WITH_NETWORK_WITH_METAQ = READING_WITH_NETWORK.clone_with_metaq()
229READING_WITH_NETWORK_WITH_METAQ = SyncDaemonState(301READING_WITH_NETWORK_WITH_CONTQ = READING_WITH_NETWORK.clone_with_contq()
230 'READING_WITH_NETWORK_WITH_METAQ',302READING_WITH_NETWORK_WITH_BOTHQ = READING_WITH_NETWORK.clone_with_bothq()
231 'doing local rescan; network is available, meta_q waiting',
232 'READING_WITH_NETWORK_WITH_METAQ',
233 'READING_WAITING_WITH_NETWORK_WITH_METAQ',
234 'READING_WITH_METAQ', 'READING_WITH_NETWORK_WITH_METAQ',
235 'READING_WITH_NETWORK_WITH_METAQ',
236 SYS_LOCAL_RESCAN_DONE='READY_WITH_NETWORK_WITH_METAQ',
237 SYS_META_QUEUE_WAITING='READING_WITH_NETWORK_WITH_METAQ',
238 SYS_META_QUEUE_DONE='READING_WITH_NETWORK',
239 SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ',
240 SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK_WITH_METAQ',
241 )
242
243READING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
244 'READING_WITH_NETWORK_WITH_CONTQ',
245 'doing local rescan; network is available, content_q waiting',
246 'READING_WITH_NETWORK_WITH_CONTQ',
247 'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
248 'READING_WITH_CONTQ', 'READING_WITH_NETWORK_WITH_CONTQ',
249 'READING_WITH_NETWORK_WITH_CONTQ',
250 SYS_LOCAL_RESCAN_DONE='READY_WITH_NETWORK_WITH_CONTQ',
251 SYS_META_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ',
252 SYS_META_QUEUE_DONE='READING_WITH_NETWORK_WITH_CONTQ',
253 SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_CONTQ',
254 SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK',
255 )
256
257READING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
258 'READING_WITH_NETWORK_WITH_BOTHQ',
259 'doing local rescan; network is available, both _q\'s waiting',
260 'READING_WITH_NETWORK_WITH_BOTHQ',
261 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
262 'READING_WITH_BOTHQ', 'READING_WITH_NETWORK_WITH_BOTHQ',
263 'READING_WITH_NETWORK_WITH_BOTHQ',
264 SYS_LOCAL_RESCAN_DONE='READY_WITH_NETWORK_WITH_BOTHQ',
265 SYS_META_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ',
266 SYS_META_QUEUE_DONE='READING_WITH_NETWORK_WITH_CONTQ',
267 SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ',
268 SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK_WITH_METAQ',
269 )
270303
271READING_WAITING = SyncDaemonState(304READING_WAITING = SyncDaemonState(
272 'READING_WAITING',305 'READING_WAITING',
@@ -279,49 +312,13 @@
279 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_CONTQ',312 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_CONTQ',
280 SYS_CONTENT_QUEUE_DONE='READING_WAITING',313 SYS_CONTENT_QUEUE_DONE='READING_WAITING',
281 )314 )
282315READING_WAITING_WITH_METAQ = READING_WAITING.clone_with_metaq()
283READING_WAITING_WITH_METAQ = SyncDaemonState(316READING_WAITING_WITH_CONTQ = READING_WAITING.clone_with_contq()
284 'READING_WAITING_WITH_METAQ',317READING_WAITING_WITH_BOTHQ = READING_WAITING.clone_with_bothq()
285 'doing local rescan; user wants to connect, meta_q waiting',
286 'READING_WAITING_WITH_NETWORK_WITH_METAQ', 'READING_WAITING_WITH_METAQ',
287 'READING_WAITING_WITH_METAQ', 'READING_WITH_METAQ',
288 'READING_WAITING_WITH_METAQ',
289 SYS_LOCAL_RESCAN_DONE='READY_WAITING_WITH_METAQ',
290 SYS_META_QUEUE_WAITING='READING_WAITING_WITH_METAQ',
291 SYS_META_QUEUE_DONE='READING_WAITING',
292 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ',
293 SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_METAQ',
294 )
295
296READING_WAITING_WITH_CONTQ = SyncDaemonState(
297 'READING_WAITING_WITH_CONTQ',
298 'doing local rescan; user wants to connect, content_q waiting',
299 'READING_WAITING_WITH_NETWORK_WITH_CONTQ', 'READING_WAITING_WITH_CONTQ',
300 'READING_WAITING_WITH_CONTQ', 'READING_WITH_CONTQ',
301 'READING_WAITING_WITH_CONTQ',
302 SYS_LOCAL_RESCAN_DONE='READY_WAITING_WITH_CONTQ',
303 SYS_META_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ',
304 SYS_META_QUEUE_DONE='READING_WAITING_WITH_CONTQ',
305 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_CONTQ',
306 SYS_CONTENT_QUEUE_DONE='READING_WAITING',
307 )
308
309READING_WAITING_WITH_BOTHQ = SyncDaemonState(
310 'READING_WAITING_WITH_BOTHQ',
311 'doing local rescan; user wants to connect, both _q\'s waiting',
312 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ', 'READING_WAITING_WITH_BOTHQ',
313 'READING_WAITING_WITH_BOTHQ', 'READING_WITH_BOTHQ',
314 'READING_WAITING_WITH_BOTHQ',
315 SYS_LOCAL_RESCAN_DONE='READY_WAITING_WITH_BOTHQ',
316 SYS_META_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ',
317 SYS_META_QUEUE_DONE='READING_WAITING_WITH_CONTQ',
318 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ',
319 SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_METAQ',
320 )
321318
322READING_WAITING_WITH_NETWORK = SyncDaemonState(319READING_WAITING_WITH_NETWORK = SyncDaemonState(
323 'READING_WAITING_WITH_NETWORK',320 'READING_WAITING_WITH_NETWORK',
324 'doing local rescan; user wants to connect, and network is available',321 'doing local rescan; user wants to connect, network is available',
325 'READING_WAITING_WITH_NETWORK', 'READING_WAITING_WITH_NETWORK',322 'READING_WAITING_WITH_NETWORK', 'READING_WAITING_WITH_NETWORK',
326 'READING_WAITING', 'READING_WITH_NETWORK',323 'READING_WAITING', 'READING_WITH_NETWORK',
327 'READING_WAITING_WITH_NETWORK',324 'READING_WAITING_WITH_NETWORK',
@@ -331,55 +328,16 @@
331 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_CONTQ',328 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_CONTQ',
332 SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK',329 SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK',
333 )330 )
334331READING_WAITING_WITH_NETWORK_WITH_METAQ = \
335READING_WAITING_WITH_NETWORK_WITH_METAQ = SyncDaemonState(332 READING_WAITING_WITH_NETWORK.clone_with_metaq()
336 'READING_WAITING_WITH_NETWORK_WITH_METAQ',333READING_WAITING_WITH_NETWORK_WITH_CONTQ = \
337 'doing local rescan; user wants to connect, network is available,'334 READING_WAITING_WITH_NETWORK.clone_with_contq()
338 ' meta_q waiting',335READING_WAITING_WITH_NETWORK_WITH_BOTHQ = \
339 'READING_WAITING_WITH_NETWORK_WITH_METAQ',336 READING_WAITING_WITH_NETWORK.clone_with_bothq()
340 'READING_WAITING_WITH_NETWORK_WITH_METAQ',
341 'READING_WAITING_WITH_METAQ', 'READING_WITH_NETWORK_WITH_METAQ',
342 'READING_WAITING_WITH_NETWORK_WITH_METAQ',
343 SYS_LOCAL_RESCAN_DONE='START_CONNECTING_WITH_METAQ',
344 SYS_META_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_METAQ',
345 SYS_META_QUEUE_DONE='READING_WAITING_WITH_NETWORK',
346 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
347 SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_METAQ',
348 )
349
350READING_WAITING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
351 'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
352 'doing local rescan; user wants to connect, network is available,'
353 ' content_q waiting',
354 'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
355 'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
356 'READING_WAITING_WITH_CONTQ', 'READING_WITH_NETWORK_WITH_CONTQ',
357 'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
358 SYS_LOCAL_RESCAN_DONE='START_CONNECTING_WITH_CONTQ',
359 SYS_META_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
360 SYS_META_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_CONTQ',
361 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_CONTQ',
362 SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK',
363 )
364
365READING_WAITING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
366 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
367 'doing local rescan; user wants to connect, network is available,'
368 ' both _q\'s waiting',
369 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
370 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
371 'READING_WAITING_WITH_BOTHQ', 'READING_WITH_NETWORK_WITH_BOTHQ',
372 'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
373 SYS_LOCAL_RESCAN_DONE='START_CONNECTING_WITH_BOTHQ',
374 SYS_META_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
375 SYS_META_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_CONTQ',
376 SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
377 SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_METAQ',
378 )
379337
380READY_FOR_NETWORK = SyncDaemonState(338READY_FOR_NETWORK = SyncDaemonState(
381 'READY_FOR_NETWORK',339 'READY_FOR_NETWORK',
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',
383 'READY_WITH_NETWORK', 'READY_WAITING',341 'READY_WITH_NETWORK', 'READY_WAITING',
384 'READY_FOR_NETWORK', 'READY_FOR_NETWORK', 'READY_FOR_NETWORK',342 'READY_FOR_NETWORK', 'READY_FOR_NETWORK', 'READY_FOR_NETWORK',
385 SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_METAQ',343 SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_METAQ',
@@ -387,49 +345,13 @@
387 SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_CONTQ',345 SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_CONTQ',
388 SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK',346 SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK',
389 )347 )
390348READY_FOR_NETWORK_WITH_METAQ = READY_FOR_NETWORK.clone_with_metaq()
391READY_FOR_NETWORK_WITH_METAQ = SyncDaemonState(349READY_FOR_NETWORK_WITH_CONTQ = READY_FOR_NETWORK.clone_with_contq()
392 'READY_FOR_NETWORK_WITH_METAQ',350READY_FOR_NETWORK_WITH_BOTHQ = READY_FOR_NETWORK.clone_with_bothq()
393 'ready to connect as soon as the user says so and the network comes up.'
394 + ' Meta queue is waiting.',
395 'READY_WITH_NETWORK_WITH_METAQ', 'READY_WAITING_WITH_METAQ',
396 'READY_FOR_NETWORK_WITH_METAQ', 'READY_FOR_NETWORK_WITH_METAQ',
397 'READY_FOR_NETWORK_WITH_METAQ',
398 SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_METAQ',
399 SYS_META_QUEUE_DONE='READY_FOR_NETWORK',
400 SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ',
401 SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK_WITH_METAQ',
402 )
403
404READY_FOR_NETWORK_WITH_CONTQ = SyncDaemonState(
405 'READY_FOR_NETWORK_WITH_CONTQ',
406 'ready to connect as soon as the user says so and the network comes up.'
407 + ' Content queue is waiting.',
408 'READY_WITH_NETWORK_WITH_CONTQ', 'READY_WAITING_WITH_CONTQ',
409 'READY_FOR_NETWORK_WITH_CONTQ', 'READY_FOR_NETWORK_WITH_CONTQ',
410 'READY_FOR_NETWORK_WITH_CONTQ',
411 SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ',
412 SYS_META_QUEUE_DONE='READY_FOR_NETWORK_WITH_CONTQ',
413 SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_CONTQ',
414 SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK',
415 )
416
417READY_FOR_NETWORK_WITH_BOTHQ = SyncDaemonState(
418 'READY_FOR_NETWORK_WITH_BOTHQ',
419 'ready to connect as soon as the user says so and the network comes up.'
420 + ' Both request queues are waiting.',
421 'READY_WITH_NETWORK_WITH_BOTHQ', 'READY_WAITING_WITH_BOTHQ',
422 'READY_FOR_NETWORK_WITH_BOTHQ', 'READY_FOR_NETWORK_WITH_BOTHQ',
423 'READY_FOR_NETWORK_WITH_BOTHQ',
424 SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ',
425 SYS_META_QUEUE_DONE='READY_FOR_NETWORK_WITH_CONTQ',
426 SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ',
427 SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK_WITH_METAQ',
428 )
429351
430READY_WITH_NETWORK = SyncDaemonState(352READY_WITH_NETWORK = SyncDaemonState(
431 'READY_WITH_NETWORK',353 'READY_WITH_NETWORK',
432 'ready to connect, network is up, user is yet to push "go"',354 'ready to connect, network up, user yet to push "go"',
433 'READY_WITH_NETWORK', 'START_CONNECTING',355 'READY_WITH_NETWORK', 'START_CONNECTING',
434 'READY_FOR_NETWORK', 'READY_WITH_NETWORK', 'READY_WITH_NETWORK',356 'READY_FOR_NETWORK', 'READY_WITH_NETWORK', 'READY_WITH_NETWORK',
435 SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_METAQ',357 SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_METAQ',
@@ -437,42 +359,9 @@
437 SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_CONTQ',359 SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_CONTQ',
438 SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK',360 SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK',
439 )361 )
440362READY_WITH_NETWORK_WITH_METAQ = READY_WITH_NETWORK.clone_with_metaq()
441READY_WITH_NETWORK_WITH_METAQ = SyncDaemonState(363READY_WITH_NETWORK_WITH_CONTQ = READY_WITH_NETWORK.clone_with_contq()
442 'READY_WITH_NETWORK_WITH_METAQ',364READY_WITH_NETWORK_WITH_BOTHQ = READY_WITH_NETWORK.clone_with_bothq()
443 'ready to connect, network up, meta_q waiting, user yet to push "go"',
444 'READY_WITH_NETWORK_WITH_METAQ', 'START_CONNECTING_WITH_METAQ',
445 'READY_FOR_NETWORK_WITH_METAQ', 'READY_WITH_NETWORK_WITH_METAQ',
446 'READY_WITH_NETWORK_WITH_METAQ',
447 SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_METAQ',
448 SYS_META_QUEUE_DONE='READY_WITH_NETWORK',
449 SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ',
450 SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK_WITH_METAQ',
451 )
452
453READY_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
454 'READY_WITH_NETWORK_WITH_CONTQ',
455 'ready to connect, network up, content_q waiting, user yet to push "go"',
456 'READY_WITH_NETWORK_WITH_CONTQ', 'START_CONNECTING_WITH_CONTQ',
457 'READY_FOR_NETWORK_WITH_CONTQ', 'READY_WITH_NETWORK_WITH_CONTQ',
458 'READY_WITH_NETWORK_WITH_CONTQ',
459 SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ',
460 SYS_META_QUEUE_DONE='READY_WITH_NETWORK_WITH_CONTQ',
461 SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_CONTQ',
462 SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK',
463 )
464
465READY_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
466 'READY_WITH_NETWORK_WITH_BOTHQ',
467 'ready to connect, network up, both _q\'s waiting, user yet to push "go"',
468 'READY_WITH_NETWORK_WITH_BOTHQ', 'START_CONNECTING_WITH_BOTHQ',
469 'READY_FOR_NETWORK_WITH_BOTHQ', 'READY_WITH_NETWORK_WITH_BOTHQ',
470 'READY_WITH_NETWORK_WITH_BOTHQ',
471 SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ',
472 SYS_META_QUEUE_DONE='READY_WITH_NETWORK_WITH_CONTQ',
473 SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ',
474 SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK_WITH_METAQ',
475 )
476365
477READY_WAITING = SyncDaemonState(366READY_WAITING = SyncDaemonState(
478 'READY_WAITING',367 'READY_WAITING',
@@ -484,42 +373,106 @@
484 SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_CONTQ',373 SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_CONTQ',
485 SYS_CONTENT_QUEUE_DONE='READY_WAITING',374 SYS_CONTENT_QUEUE_DONE='READY_WAITING',
486)375)
487376READY_WAITING_WITH_METAQ = READY_WAITING.clone_with_metaq()
488READY_WAITING_WITH_METAQ = SyncDaemonState(377READY_WAITING_WITH_CONTQ = READY_WAITING.clone_with_contq()
489 'READY_WAITING_WITH_METAQ',378READY_WAITING_WITH_BOTHQ = READY_WAITING.clone_with_bothq()
490 'ready to connect; user said "go", network is down, meta_q waiting',379
491 'START_CONNECTING_WITH_METAQ', 'READY_WAITING_WITH_METAQ',380START_STANDOFF_WAITING_WITH_NETWORK = SyncDaemonState(
492 'READY_WAITING_WITH_METAQ', 'READY_FOR_NETWORK_WITH_METAQ',381 'START_STANDOFF_WAITING_WITH_NETWORK',
493 'READY_WAITING_WITH_METAQ',382 'disconnect and wait for SYS_CONNECTION_LOST, then go on to connect',
494 SYS_META_QUEUE_DONE='READY_WAITING',383 'STANDOFF_WAITING_WITH_NETWORK', 'STANDOFF_WAITING_WITH_NETWORK',
495 SYS_META_QUEUE_WAITING='READY_WAITING_WITH_METAQ',384 'STANDOFF_WAITING', 'STANDOFF_WITH_NETWORK',
496 SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ',385 'START_CONNECTING',
497 SYS_CONTENT_QUEUE_DONE='READY_WAITING_WITH_METAQ',386 SYS_META_QUEUE_WAITING='STANDOFF_WAITING_WITH_NETWORK_WITH_METAQ',
498)387 SYS_META_QUEUE_DONE='STANDOFF_WAITING_WITH_NETWORK',
499388 SYS_CONTENT_QUEUE_WAITING='STANDOFF_WAITING_WITH_NETWORK_WITH_CONTQ',
500READY_WAITING_WITH_CONTQ = SyncDaemonState(389 SYS_CONTENT_QUEUE_DONE='STANDOFF_WAITING_WITH_NETWORK',
501 'READY_WAITING_WITH_CONTQ',390 enter=lambda m: m.action_q.disconnect(),
502 'ready to connect; user said "go", network is down, content_q waiting',391)
503 'START_CONNECTING_WITH_CONTQ', 'READY_WAITING_WITH_CONTQ',392START_STANDOFF_WAITING_WITH_NETWORK_WITH_METAQ = \
504 'READY_WAITING_WITH_CONTQ', 'READY_FOR_NETWORK_WITH_CONTQ',393 START_STANDOFF_WAITING_WITH_NETWORK.clone_with_metaq()
505 'READY_WAITING_WITH_CONTQ',394START_STANDOFF_WAITING_WITH_NETWORK_WITH_CONTQ = \
506 SYS_META_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ',395 START_STANDOFF_WAITING_WITH_NETWORK.clone_with_contq()
507 SYS_META_QUEUE_DONE='READY_WAITING_WITH_CONTQ',396START_STANDOFF_WAITING_WITH_NETWORK_WITH_BOTHQ = \
508 SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_CONTQ',397 START_STANDOFF_WAITING_WITH_NETWORK.clone_with_bothq()
509 SYS_CONTENT_QUEUE_DONE='READY_WAITING',398STANDOFF_WAITING_WITH_NETWORK = \
510)399 START_STANDOFF_WAITING_WITH_NETWORK.clone_with_no_start(
511400 'wait for SYS_CONNECTION_LOST, then go on to connect')
512READY_WAITING_WITH_BOTHQ = SyncDaemonState(401STANDOFF_WAITING_WITH_NETWORK_WITH_METAQ = \
513 'READY_WAITING_WITH_BOTHQ',402 STANDOFF_WAITING_WITH_NETWORK.clone_with_metaq()
514 'ready to connect; user said "go", network is down, both _q\'s waiting',403STANDOFF_WAITING_WITH_NETWORK_WITH_CONTQ = \
515 'START_CONNECTING_WITH_BOTHQ', 'READY_WAITING_WITH_BOTHQ',404 STANDOFF_WAITING_WITH_NETWORK.clone_with_contq()
516 'READY_WAITING_WITH_BOTHQ', 'READY_FOR_NETWORK_WITH_BOTHQ',405STANDOFF_WAITING_WITH_NETWORK_WITH_BOTHQ = \
517 'READY_WAITING_WITH_BOTHQ',406 STANDOFF_WAITING_WITH_NETWORK.clone_with_bothq()
518 SYS_META_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ',407
519 SYS_META_QUEUE_DONE='READY_WAITING_WITH_CONTQ',408START_STANDOFF_WITH_NETWORK = SyncDaemonState(
520 SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ',409 'START_STANDOFF_WITH_NETWORK',
521 SYS_CONTENT_QUEUE_DONE='READY_WAITING_WITH_METAQ',410 'disconnect and wait for SYS_CONNECTION_LOST;'
522)411 ' network present, but asked not to connect',
412 'STANDOFF_WITH_NETWORK', 'STANDOFF_WAITING_WITH_NETWORK',
413 'STANDOFF', 'STANDOFF_WITH_NETWORK',
414 'READY_WITH_NETWORK',
415 SYS_META_QUEUE_WAITING='STANDOFF_WITH_NETWORK_WITH_METAQ',
416 SYS_META_QUEUE_DONE='STANDOFF_WITH_NETWORK',
417 SYS_CONTENT_QUEUE_WAITING='STANDOFF_WITH_NETWORK_WITH_CONTQ',
418 SYS_CONTENT_QUEUE_DONE='STANDOFF_WITH_NETWORK',
419 enter=lambda m: m.action_q.disconnect(),
420)
421START_STANDOFF_WITH_NETWORK_WITH_METAQ = \
422 START_STANDOFF_WITH_NETWORK.clone_with_metaq()
423START_STANDOFF_WITH_NETWORK_WITH_CONTQ = \
424 START_STANDOFF_WITH_NETWORK.clone_with_contq()
425START_STANDOFF_WITH_NETWORK_WITH_BOTHQ = \
426 START_STANDOFF_WITH_NETWORK.clone_with_bothq()
427STANDOFF_WITH_NETWORK = START_STANDOFF_WITH_NETWORK.clone_with_no_start(
428 'wait for SYS_CONNECTION_LOST; network present, but asked not to connect')
429STANDOFF_WITH_NETWORK_WITH_METAQ = STANDOFF_WITH_NETWORK.clone_with_metaq()
430STANDOFF_WITH_NETWORK_WITH_CONTQ = STANDOFF_WITH_NETWORK.clone_with_contq()
431STANDOFF_WITH_NETWORK_WITH_BOTHQ = STANDOFF_WITH_NETWORK.clone_with_bothq()
432
433START_STANDOFF_WAITING = SyncDaemonState(
434 'START_STANDOFF_WAITING',
435 'disconnect and wait for SYS_CONNECTION_LOST;'
436 ' wanting to connect but no network present',
437 'STANDOFF_WAITING_WITH_NETWORK', 'STANDOFF_WAITING',
438 'STANDOFF_WAITING', 'STANDOFF',
439 'READY_WAITING',
440 SYS_META_QUEUE_WAITING='STANDOFF_WAITING_WITH_METAQ',
441 SYS_META_QUEUE_DONE='STANDOFF_WAITING',
442 SYS_CONTENT_QUEUE_WAITING='STANDOFF_WAITING_WITH_CONTQ',
443 SYS_CONTENT_QUEUE_DONE='STANDOFF_WAITING',
444 enter=lambda m: m.action_q.disconnect(),
445)
446START_STANDOFF_WAITING_WITH_METAQ = START_STANDOFF_WAITING.clone_with_metaq()
447START_STANDOFF_WAITING_WITH_CONTQ = START_STANDOFF_WAITING.clone_with_contq()
448START_STANDOFF_WAITING_WITH_BOTHQ = START_STANDOFF_WAITING.clone_with_bothq()
449STANDOFF_WAITING = START_STANDOFF_WAITING.clone_with_no_start(
450 'wait for SYS_CONNECTION_LOST; wanting to connect but no network present')
451STANDOFF_WAITING_WITH_METAQ = STANDOFF_WAITING.clone_with_metaq()
452STANDOFF_WAITING_WITH_CONTQ = STANDOFF_WAITING.clone_with_contq()
453STANDOFF_WAITING_WITH_BOTHQ = STANDOFF_WAITING.clone_with_bothq()
454
455START_STANDOFF = SyncDaemonState(
456 'START_STANDOFF',
457 'disconnect and wait for SYS_CONNECTION_LOST;'
458 ' no network present, not wanting to connect',
459 'STANDOFF_WITH_NETWORK', 'STANDOFF_WAITING',
460 'STANDOFF', 'STANDOFF',
461 'READY_FOR_NETWORK',
462 SYS_META_QUEUE_WAITING='STANDOFF_WITH_METAQ',
463 SYS_META_QUEUE_DONE='STANDOFF',
464 SYS_CONTENT_QUEUE_WAITING='STANDOFF_WITH_CONTQ',
465 SYS_CONTENT_QUEUE_DONE='STANDOFF',
466 enter=lambda m: m.action_q.disconnect(),
467)
468START_STANDOFF_WITH_METAQ = START_STANDOFF.clone_with_metaq()
469START_STANDOFF_WITH_CONTQ = START_STANDOFF.clone_with_contq()
470START_STANDOFF_WITH_BOTHQ = START_STANDOFF.clone_with_bothq()
471STANDOFF = START_STANDOFF.clone_with_no_start(
472 'wait for SYS_CONNECTION_LOST; no network present, not wanting to connect')
473STANDOFF_WITH_METAQ = STANDOFF.clone_with_metaq()
474STANDOFF_WITH_CONTQ = STANDOFF.clone_with_contq()
475STANDOFF_WITH_BOTHQ = STANDOFF.clone_with_bothq()
523476
524START_CONNECTING = SyncDaemonState(477START_CONNECTING = SyncDaemonState(
525 'START_CONNECTING',478 'START_CONNECTING',
@@ -531,109 +484,18 @@
531 SYS_META_QUEUE_DONE='CONNECTING',484 SYS_META_QUEUE_DONE='CONNECTING',
532 SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ',485 SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ',
533 SYS_CONTENT_QUEUE_DONE='CONNECTING',486 SYS_CONTENT_QUEUE_DONE='CONNECTING',
534 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',487 SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK',
535 enter=lambda m: m.action_q.connect(),488 enter=lambda m: m.action_q.connect(),
536 )489 )
537490START_CONNECTING_WITH_METAQ = START_CONNECTING.clone_with_metaq()
538START_CONNECTING_WITH_METAQ = SyncDaemonState(491START_CONNECTING_WITH_CONTQ = START_CONNECTING.clone_with_contq()
539 'START_CONNECTING_WITH_METAQ',492START_CONNECTING_WITH_BOTHQ = START_CONNECTING.clone_with_bothq()
540 'started waiting for the socket to come up; meta_q waiting',493
541 'CONNECTING_WITH_METAQ', 'CONNECTING_WITH_METAQ',494CONNECTING = START_CONNECTING.clone_with_no_start(
542 'READY_WAITING_WITH_METAQ', 'READY_WITH_NETWORK_WITH_METAQ',495 'waiting for the socket to come up')
543 'START_CONNECTING_WITH_METAQ',496CONNECTING_WITH_METAQ = CONNECTING.clone_with_metaq()
544 SYS_CONNECTION_MADE='START_CONNECTED_WITH_METAQ',497CONNECTING_WITH_CONTQ = CONNECTING.clone_with_contq()
545 SYS_META_QUEUE_WAITING='CONNECTING_WITH_METAQ',498CONNECTING_WITH_BOTHQ = CONNECTING.clone_with_bothq()
546 SYS_META_QUEUE_DONE='CONNECTING',
547 SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
548 SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ',
549 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
550 enter=lambda m: m.action_q.connect(),
551 )
552
553START_CONNECTING_WITH_CONTQ = SyncDaemonState(
554 'START_CONNECTING_WITH_CONTQ',
555 'started waiting for the socket to come up; content_q waiting',
556 'CONNECTING_WITH_CONTQ', 'CONNECTING_WITH_CONTQ',
557 'READY_WAITING_WITH_CONTQ', 'READY_WITH_NETWORK_WITH_CONTQ',
558 'START_CONNECTING_WITH_CONTQ',
559 SYS_CONNECTION_MADE='START_CONNECTED_WITH_CONTQ',
560 SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
561 SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ',
562 SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ',
563 SYS_CONTENT_QUEUE_DONE='CONNECTING',
564 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
565 enter=lambda m: m.action_q.connect(),
566 )
567
568START_CONNECTING_WITH_BOTHQ = SyncDaemonState(
569 'START_CONNECTING_WITH_BOTHQ',
570 'started waiting for the socket to come up; both _q\'s waiting',
571 'CONNECTING_WITH_BOTHQ', 'CONNECTING_WITH_BOTHQ',
572 'READY_WAITING_WITH_BOTHQ', 'READY_WITH_NETWORK_WITH_BOTHQ',
573 'START_CONNECTING_WITH_BOTHQ',
574 SYS_CONNECTION_MADE='START_CONNECTED_WITH_BOTHQ',
575 SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
576 SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ',
577 SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
578 SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ',
579 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
580 enter=lambda m: m.action_q.connect(),
581 )
582
583CONNECTING = SyncDaemonState(
584 'CONNECTING',
585 'waiting for the socket to come up',
586 'CONNECTING', 'CONNECTING',
587 'READY_WAITING', 'READY_WITH_NETWORK', 'START_CONNECTING',
588 SYS_CONNECTION_MADE='START_CONNECTED',
589 SYS_META_QUEUE_WAITING='CONNECTING_WITH_METAQ',
590 SYS_META_QUEUE_DONE='CONNECTING',
591 SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ',
592 SYS_CONTENT_QUEUE_DONE='CONNECTING',
593 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
594 )
595
596CONNECTING_WITH_METAQ = SyncDaemonState(
597 'CONNECTING_WITH_METAQ',
598 'waiting for the socket to come up; meta_q waiting',
599 'CONNECTING_WITH_METAQ', 'CONNECTING_WITH_METAQ',
600 'READY_WAITING_WITH_METAQ', 'READY_WITH_NETWORK_WITH_METAQ',
601 'START_CONNECTING_WITH_METAQ',
602 SYS_CONNECTION_MADE='START_CONNECTED_WITH_METAQ',
603 SYS_META_QUEUE_WAITING='CONNECTING_WITH_METAQ',
604 SYS_META_QUEUE_DONE='CONNECTING',
605 SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
606 SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ',
607 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
608 )
609
610CONNECTING_WITH_CONTQ = SyncDaemonState(
611 'CONNECTING_WITH_CONTQ',
612 'waiting for the socket to come up; content_q waiting',
613 'CONNECTING_WITH_CONTQ', 'CONNECTING_WITH_CONTQ',
614 'READY_WAITING_WITH_CONTQ', 'READY_WITH_NETWORK_WITH_CONTQ',
615 'START_CONNECTING_WITH_CONTQ',
616 SYS_CONNECTION_MADE='START_CONNECTED_WITH_CONTQ',
617 SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
618 SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ',
619 SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ',
620 SYS_CONTENT_QUEUE_DONE='CONNECTING',
621 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
622 )
623
624CONNECTING_WITH_BOTHQ = SyncDaemonState(
625 'CONNECTING_WITH_BOTHQ',
626 'waiting for the socket to come up; both _q\'s waiting',
627 'CONNECTING_WITH_BOTHQ', 'CONNECTING_WITH_BOTHQ',
628 'READY_WAITING_WITH_BOTHQ', 'READY_WITH_NETWORK_WITH_BOTHQ',
629 'START_CONNECTING_WITH_BOTHQ',
630 SYS_CONNECTION_MADE='START_CONNECTED_WITH_BOTHQ',
631 SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
632 SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ',
633 SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
634 SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ',
635 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
636 )
637499
638START_CONNECTED = NonActiveConnectedSDState(500START_CONNECTED = NonActiveConnectedSDState(
639 'START_CONNECTED',501 'START_CONNECTED',
@@ -644,102 +506,17 @@
644 SYS_META_QUEUE_DONE='CONNECTED',506 SYS_META_QUEUE_DONE='CONNECTED',
645 SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ',507 SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ',
646 SYS_CONTENT_QUEUE_DONE='CONNECTED',508 SYS_CONTENT_QUEUE_DONE='CONNECTED',
647 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',509 SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK',
648 enter=lambda m: m.check_version(),510 enter=lambda m: m.check_version(),
649 )511 )
650512START_CONNECTED_WITH_METAQ = START_CONNECTED.clone_with_metaq()
651START_CONNECTED_WITH_METAQ = NonActiveConnectedSDState(513START_CONNECTED_WITH_CONTQ = START_CONNECTED.clone_with_contq()
652 'START_CONNECTED_WITH_METAQ',514START_CONNECTED_WITH_BOTHQ = START_CONNECTED.clone_with_bothq()
653 'socket came up! start checking protocol version; meta_q waiting',515CONNECTED = START_CONNECTED.clone_with_no_start('socket came up!'
654 with_q='METAQ',516 ' checking protocol version')
655 SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',517CONNECTED_WITH_METAQ = CONNECTED.clone_with_metaq()
656 SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_METAQ',518CONNECTED_WITH_CONTQ = CONNECTED.clone_with_contq()
657 SYS_META_QUEUE_WAITING='CONNECTED_WITH_METAQ',519CONNECTED_WITH_BOTHQ = CONNECTED.clone_with_bothq()
658 SYS_META_QUEUE_DONE='CONNECTED',
659 SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
660 SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ',
661 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
662 enter=lambda m: m.check_version(),
663 )
664
665START_CONNECTED_WITH_CONTQ = NonActiveConnectedSDState(
666 'START_CONNECTED_WITH_CONTQ',
667 'socket came up! start checking protocol version; content_q waiting',
668 with_q='CONTQ',
669 SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
670 SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_CONTQ',
671 SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
672 SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ',
673 SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ',
674 SYS_CONTENT_QUEUE_DONE='CONNECTED',
675 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
676 enter=lambda m: m.check_version(),
677 )
678
679START_CONNECTED_WITH_BOTHQ = NonActiveConnectedSDState(
680 'START_CONNECTED_WITH_BOTHQ',
681 'socket came up! start checking protocol version both _q\'s waiting',
682 with_q='BOTHQ',
683 SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
684 SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_BOTHQ',
685 SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
686 SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ',
687 SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
688 SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ',
689 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
690 enter=lambda m: m.check_version(),
691 )
692
693CONNECTED = NonActiveConnectedSDState(
694 'CONNECTED',
695 'socket came up! checking protocol version',
696 SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
697 SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES',
698 SYS_META_QUEUE_WAITING='CONNECTED_WITH_METAQ',
699 SYS_META_QUEUE_DONE='CONNECTED',
700 SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ',
701 SYS_CONTENT_QUEUE_DONE='CONNECTED',
702 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
703 )
704
705CONNECTED_WITH_METAQ = NonActiveConnectedSDState(
706 'CONNECTED_WITH_METAQ',
707 'socket came up! checking protocol version; meta_q waiting',
708 with_q='METAQ',
709 SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
710 SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_METAQ',
711 SYS_META_QUEUE_WAITING='CONNECTED_WITH_METAQ',
712 SYS_META_QUEUE_DONE='CONNECTED',
713 SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
714 SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ',
715 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
716 )
717
718CONNECTED_WITH_CONTQ = NonActiveConnectedSDState(
719 'CONNECTED_WITH_CONTQ',
720 'socket came up! checking protocol version; content_q waiting',
721 with_q='CONTQ',
722 SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
723 SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_CONTQ',
724 SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
725 SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ',
726 SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ',
727 SYS_CONTENT_QUEUE_DONE='CONNECTED',
728 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
729 )
730
731CONNECTED_WITH_BOTHQ = NonActiveConnectedSDState(
732 'CONNECTED_WITH_BOTHQ',
733 'socket came up! checking protocol version both _q\'s waiting',
734 with_q='BOTHQ',
735 SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
736 SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_BOTHQ',
737 SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
738 SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ',
739 SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
740 SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ',
741 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
742 )
743520
744BAD_VERSION = AQErrorState(521BAD_VERSION = AQErrorState(
745 'BAD_VERSION',522 'BAD_VERSION',
@@ -755,102 +532,17 @@
755 SYS_META_QUEUE_DONE='SET_CAPABILITIES',532 SYS_META_QUEUE_DONE='SET_CAPABILITIES',
756 SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ',533 SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ',
757 SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES',534 SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES',
758 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',535 SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK',
759 enter=lambda m: m.set_capabilities(),536 enter=lambda m: m.set_capabilities(),
760 )537 )
761538START_SET_CAPABILITIES_WITH_METAQ = START_SET_CAPABILITIES.clone_with_metaq()
762START_SET_CAPABILITIES_WITH_METAQ = NonActiveConnectedSDState(539START_SET_CAPABILITIES_WITH_CONTQ = START_SET_CAPABILITIES.clone_with_contq()
763 'START_SET_CAPABILITIES_WITH_METAQ',540START_SET_CAPABILITIES_WITH_BOTHQ = START_SET_CAPABILITIES.clone_with_bothq()
764 'protocol version is OK! start checking capabilities; meta_q waiting',541SET_CAPABILITIES = START_SET_CAPABILITIES.clone_with_no_start(
765 with_q='METAQ',542 'protocol version is OK! checking capabilities')
766 SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',543SET_CAPABILITIES_WITH_METAQ = SET_CAPABILITIES.clone_with_metaq()
767 SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_METAQ',544SET_CAPABILITIES_WITH_CONTQ = SET_CAPABILITIES.clone_with_contq()
768 SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_METAQ',545SET_CAPABILITIES_WITH_BOTHQ = SET_CAPABILITIES.clone_with_bothq()
769 SYS_META_QUEUE_DONE='SET_CAPABILITIES',
770 SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
771 SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ',
772 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
773 enter=lambda m: m.set_capabilities(),
774 )
775
776START_SET_CAPABILITIES_WITH_CONTQ = NonActiveConnectedSDState(
777 'START_SET_CAPABILITIES_WITH_CONTQ',
778 'protocol version is OK! start checking capabilities; content_q waiting',
779 with_q='CONTQ',
780 SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
781 SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_CONTQ',
782 SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
783 SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ',
784 SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ',
785 SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES',
786 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
787 enter=lambda m: m.set_capabilities(),
788 )
789
790START_SET_CAPABILITIES_WITH_BOTHQ = NonActiveConnectedSDState(
791 'START_SET_CAPABILITIES_WITH_BOTHQ',
792 'protocol version is OK! start checking capabilities; both _q\'s waiting',
793 with_q='BOTHQ',
794 SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
795 SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_BOTHQ',
796 SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
797 SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ',
798 SYS_CONTENT_QUEUE_WAITING='START_SET_CAPABILITIES_WITH_BOTHQ',
799 SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ',
800 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
801 enter=lambda m: m.set_capabilities(),
802 )
803
804SET_CAPABILITIES = NonActiveConnectedSDState(
805 'SET_CAPABILITIES',
806 'capabilities OK, do the auth!',
807 SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
808 SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING',
809 SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_METAQ',
810 SYS_META_QUEUE_DONE='SET_CAPABILITIES',
811 SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ',
812 SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES',
813 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
814 )
815
816SET_CAPABILITIES_WITH_METAQ = NonActiveConnectedSDState(
817 'SET_CAPABILITIES_WITH_METAQ',
818 'capabilities OK, do the auth!; meta_q waiting',
819 with_q='METAQ',
820 SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
821 SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_METAQ',
822 SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_METAQ',
823 SYS_META_QUEUE_DONE='SET_CAPABILITIES',
824 SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
825 SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ',
826 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
827 )
828
829SET_CAPABILITIES_WITH_CONTQ = NonActiveConnectedSDState(
830 'SET_CAPABILITIES_WITH_CONTQ',
831 'capabilities OK, do the auth!; cont_q waiting',
832 with_q='CONTQ',
833 SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
834 SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_CONTQ',
835 SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
836 SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ',
837 SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ',
838 SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES',
839 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
840 )
841
842SET_CAPABILITIES_WITH_BOTHQ = NonActiveConnectedSDState(
843 'SET_CAPABILITIES_WITH_BOTHQ',
844 'capabilities OK, do the auth!; both _q\'s waiting',
845 with_q='BOTHQ',
846 SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
847 SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_BOTHQ',
848 SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
849 SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ',
850 SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
851 SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ',
852 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
853 )
854546
855CAPABILITIES_MISMATCH = AQErrorState(547CAPABILITIES_MISMATCH = AQErrorState(
856 'CAPABILITIES_MISMATCH',548 'CAPABILITIES_MISMATCH',
@@ -860,108 +552,23 @@
860START_AUTHENTICATING = NonActiveConnectedSDState(552START_AUTHENTICATING = NonActiveConnectedSDState(
861 'START_AUTHENTICATING',553 'START_AUTHENTICATING',
862 'Start doing the OAuth dance',554 'Start doing the OAuth dance',
863 SYS_OAUTH_OK='SCANNING_START',555 SYS_OAUTH_OK='START_SCANNING',
864 SYS_OAUTH_ERROR='AUTH_FAILED',556 SYS_OAUTH_ERROR='AUTH_FAILED',
865 SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',557 SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',
866 SYS_META_QUEUE_DONE='AUTHENTICATING',558 SYS_META_QUEUE_DONE='AUTHENTICATING',
867 SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',559 SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',
868 SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',560 SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',
869 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',561 SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK',
870 enter=lambda m: m.authenticate(),562 enter=lambda m: m.authenticate(),
871 )563 )
872564START_AUTHENTICATING_WITH_METAQ = START_AUTHENTICATING.clone_with_metaq()
873START_AUTHENTICATING_WITH_METAQ = NonActiveConnectedSDState(565START_AUTHENTICATING_WITH_CONTQ = START_AUTHENTICATING.clone_with_contq()
874 'START_AUTHENTICATING_WITH_METAQ',566START_AUTHENTICATING_WITH_BOTHQ = START_AUTHENTICATING.clone_with_bothq()
875 'Start doing the OAuth dance; meta_q waiting',567AUTHENTICATING = START_AUTHENTICATING.clone_with_no_start(
876 with_q='METAQ',568 'Doing the OAuth dance')
877 SYS_OAUTH_OK='SCANNING_START_WITH_METAQ',569AUTHENTICATING_WITH_METAQ = AUTHENTICATING.clone_with_metaq()
878 SYS_OAUTH_ERROR='AUTH_FAILED',570AUTHENTICATING_WITH_CONTQ = AUTHENTICATING.clone_with_contq()
879 SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',571AUTHENTICATING_WITH_BOTHQ = AUTHENTICATING.clone_with_bothq()
880 SYS_META_QUEUE_DONE='AUTHENTICATING',
881 SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
882 SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ',
883 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
884 enter=lambda m: m.authenticate(),
885 )
886
887START_AUTHENTICATING_WITH_CONTQ = NonActiveConnectedSDState(
888 'START_AUTHENTICATING_WITH_CONTQ',
889 'Start doing the OAuth dance; content_q waiting',
890 with_q='CONTQ',
891 SYS_OAUTH_OK='SCANNING_START_WITH_CONTQ',
892 SYS_OAUTH_ERROR='AUTH_FAILED',
893 SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
894 SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ',
895 SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',
896 SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',
897 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
898 enter=lambda m: m.authenticate(),
899 )
900
901START_AUTHENTICATING_WITH_BOTHQ = NonActiveConnectedSDState(
902 'START_AUTHENTICATING_WITH_BOTHQ',
903 'Start doing the OAuth dance; both _q\'s waiting',
904 with_q='CONTQ',
905 SYS_OAUTH_OK='SCANNING_START_WITH_BOTHQ',
906 SYS_OAUTH_ERROR='AUTH_FAILED',
907 SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
908 SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ',
909 SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
910 SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ',
911 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
912 enter=lambda m: m.authenticate(),
913 )
914
915AUTHENTICATING = NonActiveConnectedSDState(
916 'AUTHENTICATING',
917 'Doing the OAuth dance',
918 SYS_OAUTH_OK='SCANNING_START',
919 SYS_OAUTH_ERROR='AUTH_FAILED',
920 SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',
921 SYS_META_QUEUE_DONE='AUTHENTICATING',
922 SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',
923 SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',
924 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
925 )
926
927AUTHENTICATING_WITH_METAQ = NonActiveConnectedSDState(
928 'AUTHENTICATING_WITH_METAQ',
929 'Doing the OAuth dance; meta_q waiting',
930 with_q='METAQ',
931 SYS_OAUTH_OK='SCANNING_START_WITH_METAQ',
932 SYS_OAUTH_ERROR='AUTH_FAILED',
933 SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',
934 SYS_META_QUEUE_DONE='AUTHENTICATING',
935 SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
936 SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ',
937 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
938 )
939
940AUTHENTICATING_WITH_CONTQ = NonActiveConnectedSDState(
941 'AUTHENTICATING_WITH_CONTQ',
942 'Doing the OAuth dance; content_q waiting',
943 with_q='CONTQ',
944 SYS_OAUTH_OK='SCANNING_START_WITH_CONTQ',
945 SYS_OAUTH_ERROR='AUTH_FAILED',
946 SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
947 SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ',
948 SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',
949 SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',
950 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
951 )
952
953AUTHENTICATING_WITH_BOTHQ = NonActiveConnectedSDState(
954 'AUTHENTICATING_WITH_BOTHQ',
955 'Doing the OAuth dance; both _q\'s waiting',
956 with_q='CONTQ',
957 SYS_OAUTH_OK='SCANNING_START_WITH_BOTHQ',
958 SYS_OAUTH_ERROR='AUTH_FAILED',
959 SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
960 SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ',
961 SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
962 SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ',
963 SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
964 )
965572
966AUTH_FAILED = AQErrorState(573AUTH_FAILED = AQErrorState(
967 'AUTH_FAILED',574 'AUTH_FAILED',
@@ -976,8 +583,8 @@
976 "Some kind of strange error happened and I can't continue",583 "Some kind of strange error happened and I can't continue",
977 enter=lambda m: m.restart())584 enter=lambda m: m.restart())
978585
979SCANNING_START = NonActiveConnectedSDState(586START_SCANNING = NonActiveConnectedSDState(
980 'SCANNING_START',587 'START_SCANNING',
981 'start doing server rescan',588 'start doing server rescan',
982 SYS_SERVER_RESCAN_STARTING='SCANNING',589 SYS_SERVER_RESCAN_STARTING='SCANNING',
983 SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ',590 SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ',
@@ -986,89 +593,17 @@
986 SYS_CONTENT_QUEUE_DONE='SCANNING',593 SYS_CONTENT_QUEUE_DONE='SCANNING',
987 enter=lambda m: m.server_rescan(),594 enter=lambda m: m.server_rescan(),
988 )595 )
989596START_SCANNING_WITH_METAQ = START_SCANNING.clone_with_metaq()
990SCANNING_START_WITH_METAQ = NonActiveConnectedSDState(597START_SCANNING_WITH_CONTQ = START_SCANNING.clone_with_contq()
991 'SCANNING_START_WITH_METAQ',598START_SCANNING_WITH_BOTHQ = START_SCANNING.clone_with_bothq()
992 'start doing server rescan, meta queue is waiting',599SCANNING = START_SCANNING.clone_with_no_start('doing server rescan',
993 with_q='METAQ',600 SYS_SERVER_RESCAN_DONE='IDLE')
994 SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_METAQ',601SCANNING_WITH_METAQ = SCANNING.clone_with_metaq(
995 SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ',602 SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA')
996 SYS_META_QUEUE_DONE='SCANNING',603SCANNING_WITH_CONTQ = SCANNING.clone_with_contq(
997 SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ',604 SYS_SERVER_RESCAN_DONE='START_WORKING_ON_CONTENT')
998 SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ',605SCANNING_WITH_BOTHQ = SCANNING.clone_with_bothq(
999 enter=lambda m: m.server_rescan(),606 SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA_WITH_CONTQ')
1000 )
1001
1002SCANNING_START_WITH_CONTQ = NonActiveConnectedSDState(
1003 'SCANNING_START_WITH_CONTQ',
1004 'start doing server rescan, content queue waiting',
1005 with_q='CONTQ',
1006 SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_CONTQ',
1007 SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
1008 SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ',
1009 SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_CONTQ',
1010 SYS_CONTENT_QUEUE_DONE='SCANNING',
1011 enter=lambda m: m.server_rescan(),
1012 )
1013
1014SCANNING_START_WITH_BOTHQ = NonActiveConnectedSDState(
1015 'SCANNING_START_WITH_BOTHQ',
1016 'start doing server rescan, both request queues waiting',
1017 with_q='CONTQ',
1018 SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_BOTHQ',
1019 SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
1020 SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ',
1021 SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
1022 SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ',
1023 enter=lambda m: m.server_rescan(),
1024 )
1025
1026SCANNING = NonActiveConnectedSDState(
1027 'SCANNING',
1028 'doing server rescan',
1029 SYS_SERVER_RESCAN_DONE='IDLE',
1030 SYS_SERVER_RESCAN_STARTING='SCANNING',
1031 SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ',
1032 SYS_META_QUEUE_DONE='SCANNING',
1033 SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_CONTQ',
1034 SYS_CONTENT_QUEUE_DONE='SCANNING',
1035 )
1036
1037SCANNING_WITH_METAQ = NonActiveConnectedSDState(
1038 'SCANNING_WITH_METAQ',
1039 'doing server rescan, meta queue is waiting',
1040 with_q='METAQ',
1041 SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA',
1042 SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_METAQ',
1043 SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ',
1044 SYS_META_QUEUE_DONE='SCANNING',
1045 SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
1046 SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ',
1047 )
1048
1049SCANNING_WITH_CONTQ = NonActiveConnectedSDState(
1050 'SCANNING_WITH_CONTQ',
1051 'doing server rescan, content queue waiting',
1052 with_q='CONTQ',
1053 SYS_SERVER_RESCAN_DONE='START_WORKING_ON_CONTENT',
1054 SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_CONTQ',
1055 SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
1056 SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ',
1057 SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_CONTQ',
1058 SYS_CONTENT_QUEUE_DONE='SCANNING',
1059 )
1060
1061SCANNING_WITH_BOTHQ = NonActiveConnectedSDState(
1062 'SCANNING_WITH_BOTHQ',
1063 'doing server rescan, both request queues waiting',
1064 with_q='CONTQ',
1065 SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA_WITH_CONTQ',
1066 SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_BOTHQ',
1067 SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
1068 SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ',
1069 SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
1070 SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ',
1071 )
1072607
1073IDLE = NonActiveConnectedSDState(608IDLE = NonActiveConnectedSDState(
1074 'IDLE',609 'IDLE',
@@ -1089,15 +624,8 @@
1089 SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',624 SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
1090 enter=lambda m: m.action_q.meta_queue.run(),625 enter=lambda m: m.action_q.meta_queue.run(),
1091 )626 )
1092627WORKING_ON_METADATA = START_WORKING_ON_METADATA.clone_with_no_start(
1093WORKING_ON_METADATA = WorkingSDState(628 'working on metadata')
1094 'WORKING_ON_METADATA',
1095 'working on metadata',
1096 SYS_META_QUEUE_WAITING='WORKING_ON_METADATA',
1097 SYS_META_QUEUE_DONE='IDLE',
1098 SYS_CONTENT_QUEUE_WAITING='WORKING_ON_METADATA_WITH_CONTQ',
1099 SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
1100 )
1101629
1102START_WORKING_ON_CONTENT = WorkingSDState(630START_WORKING_ON_CONTENT = WorkingSDState(
1103 'START_WORKING_ON_CONTENT',631 'START_WORKING_ON_CONTENT',
@@ -1108,15 +636,8 @@
1108 SYS_CONTENT_QUEUE_DONE='IDLE',636 SYS_CONTENT_QUEUE_DONE='IDLE',
1109 enter=lambda m: m.action_q.content_queue.run(),637 enter=lambda m: m.action_q.content_queue.run(),
1110 )638 )
1111639WORKING_ON_CONTENT = START_WORKING_ON_CONTENT.clone_with_no_start(
1112WORKING_ON_CONTENT = WorkingSDState(640 'working on content')
1113 'WORKING_ON_CONTENT',
1114 'working on content',
1115 SYS_META_QUEUE_WAITING='START_WORKING_ON_BOTH',
1116 SYS_META_QUEUE_DONE='WORKING_ON_CONTENT',
1117 SYS_CONTENT_QUEUE_WAITING='WORKING_ON_CONTENT',
1118 SYS_CONTENT_QUEUE_DONE='IDLE',
1119 )
1120641
1121START_WORKING_ON_METADATA_WITH_CONTQ = WorkingSDState(642START_WORKING_ON_METADATA_WITH_CONTQ = WorkingSDState(
1122 'START_WORKING_ON_METADATA_WITH_CONTQ',643 'START_WORKING_ON_METADATA_WITH_CONTQ',
@@ -1128,364 +649,208 @@
1128 SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',649 SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
1129 enter=lambda m: m.action_q.meta_queue.run(),650 enter=lambda m: m.action_q.meta_queue.run(),
1130 )651 )
1131652WORKING_ON_METADATA_WITH_CONTQ = \
1132WORKING_ON_METADATA_WITH_CONTQ = WorkingSDState(653 START_WORKING_ON_METADATA_WITH_CONTQ.clone_with_no_start(
1133 'WORKING_ON_METADATA_WITH_CONTQ',654 'working on metadata; content work is waiting')
1134 'working on metadata; content work is waiting',
1135 with_q='CONTQ',
1136 SYS_META_QUEUE_WAITING='WORKING_ON_METADATA_WITH_CONTQ',
1137 SYS_META_QUEUE_DONE='START_WORKING_ON_CONTENT',
1138 SYS_CONTENT_QUEUE_WAITING='WORKING_ON_METADATA_WITH_CONTQ',
1139 SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
1140 )
1141655
1142START_WORKING_ON_BOTH = WorkingSDState(656START_WORKING_ON_BOTH = WorkingSDState(
1143 'START_WORKING_ON_BOTH',657 'START_WORKING_ON_BOTH',
1144 'start working on both content and metadata',658 'start working on both content and metadata',
1145 with_q='BOTHQ',
1146 SYS_META_QUEUE_WAITING='WORKING_ON_BOTH',659 SYS_META_QUEUE_WAITING='WORKING_ON_BOTH',
1147 SYS_META_QUEUE_DONE='WORKING_ON_CONTENT',660 SYS_META_QUEUE_DONE='WORKING_ON_CONTENT',
1148 SYS_CONTENT_QUEUE_WAITING='WORKING_ON_BOTH',661 SYS_CONTENT_QUEUE_WAITING='WORKING_ON_BOTH',
1149 SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',662 SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
1150 enter=lambda m: m.action_q.meta_queue.run(),663 enter=lambda m: m.action_q.meta_queue.run(),
1151 )664 )
1152665WORKING_ON_BOTH = START_WORKING_ON_BOTH.clone_with_no_start(
1153WORKING_ON_BOTH = WorkingSDState(666 'working on both content and metadata')
1154 'WORKING_ON_BOTH',
1155 'working on both content and metadata',
1156 with_q='BOTHQ',
1157 SYS_META_QUEUE_WAITING='WORKING_ON_BOTH',
1158 SYS_META_QUEUE_DONE='WORKING_ON_CONTENT',
1159 SYS_CONTENT_QUEUE_WAITING='WORKING_ON_BOTH',
1160 SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
1161 )
1162667
1163CLEANUP = SyncDaemonState(668CLEANUP = SyncDaemonState(
1164 'CLEANUP',669 'CLEANUP',
1165 'doing cleanup (net down, user asked for shutdown)',670 'doing cleanup; net down, user asked for shutdown',
1166 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING',671 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING',
1167 'CLEANUP', 'CLEANUP', 'CLEANUP',672 'CLEANUP', 'CLEANUP', 'CLEANUP_WITH_CONNECTION_LOST',
1168 SYS_CLEANUP_STARTED='CLEANUP',673 SYS_CLEANUP_STARTED='CLEANUP',
1169 SYS_CLEANUP_FINISHED='READY_FOR_NETWORK',674 SYS_CLEANUP_FINISHED='START_STANDOFF',
1170 SYS_META_QUEUE_WAITING='CLEANUP_WITH_METAQ',675 SYS_META_QUEUE_WAITING='CLEANUP_WITH_METAQ',
1171 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONTQ',676 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONTQ',
1172 SYS_META_QUEUE_DONE='CLEANUP', # cancelling meta_q.head can do this677 SYS_META_QUEUE_DONE='CLEANUP', # cancelling meta_q.head can do this
1173 SYS_CONTENT_QUEUE_DONE='CLEANUP', # ditto678 SYS_CONTENT_QUEUE_DONE='CLEANUP', # ditto
1174 )679 )
1175680CLEANUP_WITH_METAQ = CLEANUP.clone_with_metaq()
1176CLEANUP_WITH_METAQ = SyncDaemonState(681CLEANUP_WITH_CONTQ = CLEANUP.clone_with_contq()
1177 'CLEANUP_WITH_METAQ',682CLEANUP_WITH_BOTHQ = CLEANUP.clone_with_bothq()
1178 'doing cleanup (net down, user asked for shutdown, meta_q waiting)',683
1179 'CLEANUP_WITH_NETWORK_WITH_METAQ', 'CLEANUP_WAITING_WITH_METAQ',684CLEANUP_WITH_CONNECTION_LOST = SyncDaemonState(
1180 'CLEANUP_WITH_METAQ', 'CLEANUP_WITH_METAQ', 'CLEANUP_WITH_METAQ',685 'CLEANUP_WITH_CONNECTION_LOST',
1181 SYS_CLEANUP_STARTED='CLEANUP_WITH_METAQ',686 'doing cleanup; net down, user asked for shutdown, connection already lost',
1182 SYS_CLEANUP_FINISHED='READY_FOR_NETWORK_WITH_METAQ',687 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
1183 SYS_META_QUEUE_WAITING='CLEANUP_WITH_METAQ',688 'CLEANUP_WAITING_WITH_CONNECTION_LOST',
1184 SYS_META_QUEUE_DONE='CLEANUP',689 'CLEANUP_WITH_CONNECTION_LOST',
1185 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_BOTHQ',690 'CLEANUP_WITH_CONNECTION_LOST',
1186 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_METAQ',691 'CLEANUP_WITH_CONNECTION_LOST',
1187 )692 SYS_CLEANUP_STARTED='CLEANUP_WITH_CONNECTION_LOST',
1188693 SYS_CLEANUP_FINISHED='START_STANDOFF',
1189CLEANUP_WITH_CONTQ = SyncDaemonState(694 SYS_META_QUEUE_WAITING='CLEANUP_WITH_CONNECTION_LOST_WITH_METAQ',
1190 'CLEANUP_WITH_CONTQ',695 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONNECTION_LOST_WITH_CONTQ',
1191 'doing cleanup (net down, user asked for shutdown, content_q waiting)',696 SYS_META_QUEUE_DONE='CLEANUP_WITH_CONNECTION_LOST',
1192 'CLEANUP_WITH_NETWORK_WITH_CONTQ', 'CLEANUP_WAITING_WITH_CONTQ',697 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_CONNECTION_LOST',
1193 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_CONTQ',698 )
1194 SYS_CLEANUP_STARTED='CLEANUP_WITH_CONTQ',699CLEANUP_WITH_CONNECTION_LOST_WITH_METAQ = \
1195 SYS_CLEANUP_FINISHED='READY_FOR_NETWORK_WITH_CONTQ',700 CLEANUP_WITH_CONNECTION_LOST.clone_with_metaq()
1196 SYS_META_QUEUE_WAITING='CLEANUP_WITH_BOTHQ',701CLEANUP_WITH_CONNECTION_LOST_WITH_CONTQ = \
1197 SYS_META_QUEUE_DONE='CLEANUP_WITH_CONTQ',702 CLEANUP_WITH_CONNECTION_LOST.clone_with_contq()
1198 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONTQ',703CLEANUP_WITH_CONNECTION_LOST_WITH_BOTHQ = \
1199 SYS_CONTENT_QUEUE_DONE='CLEANUP',704 CLEANUP_WITH_CONNECTION_LOST.clone_with_bothq()
1200 )
1201
1202CLEANUP_WITH_BOTHQ = SyncDaemonState(
1203 'CLEANUP_WITH_BOTHQ',
1204 'doing cleanup (net down, user asked for shutdown, both _q\'s waiting)',
1205 'CLEANUP_WITH_NETWORK_WITH_BOTHQ', 'CLEANUP_WAITING_WITH_BOTHQ',
1206 'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ',
1207 SYS_CLEANUP_STARTED='CLEANUP_WITH_BOTHQ',
1208 SYS_CLEANUP_FINISHED='READY_FOR_NETWORK_WITH_BOTHQ',
1209 SYS_META_QUEUE_WAITING='CLEANUP_WITH_BOTHQ',
1210 SYS_META_QUEUE_DONE='CLEANUP_WITH_CONTQ',
1211 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_BOTHQ',
1212 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_METAQ',
1213 )
1214705
1215START_CLEANUP_WAITING = SyncDaemonState(706START_CLEANUP_WAITING = SyncDaemonState(
1216 'START_CLEANUP_WAITING',707 'START_CLEANUP_WAITING',
1217 'start doing cleanup (network dropped)',708 'start doing cleanup; network dropped',
1218 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING',709 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING',
1219 'CLEANUP_WAITING', 'CLEANUP', 'CLEANUP_WAITING',710 'CLEANUP_WAITING', 'CLEANUP',
1220 SYS_CLEANUP_STARTED='CLEANUP_WAITING',711 'CLEANUP_WAITING_WITH_CONNECTION_LOST',
1221 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ',712 SYS_CLEANUP_STARTED='CLEANUP_WAITING',
1222 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',713 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ',
1223 SYS_META_QUEUE_DONE='CLEANUP_WAITING',714 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',
1224 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',715 SYS_META_QUEUE_DONE='CLEANUP_WAITING',
1225 enter=lambda m: m.action_q.cleanup(),716 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',
1226 )717 enter=lambda m: m.action_q.cleanup(),
1227718 )
1228START_CLEANUP_WAITING_WITH_CONTQ = SyncDaemonState(719START_CLEANUP_WAITING_WITH_CONTQ = START_CLEANUP_WAITING.clone_with_contq()
1229 'START_CLEANUP_WAITING_WITH_CONTQ',720# START_CLEANUP_WAITING_WITH_BOTHQ = START_CLEANUP_WAITING.clone_with_bothq()
1230 'start doing cleanup (network dropped; contq waiting)',721CLEANUP_WAITING = START_CLEANUP_WAITING.clone_with_no_start(
1231 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',722 'doing cleanup; network dropped',
1232 'CLEANUP_WAITING_WITH_CONTQ',723 SYS_CLEANUP_FINISHED='START_STANDOFF_WAITING')
1233 'CLEANUP_WAITING_WITH_CONTQ', 'CLEANUP_WITH_CONTQ',724CLEANUP_WAITING_WITH_METAQ = CLEANUP_WAITING.clone_with_metaq()
1234 'CLEANUP_WAITING_WITH_CONTQ',725CLEANUP_WAITING_WITH_CONTQ = CLEANUP_WAITING.clone_with_contq()
1235 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_CONTQ',726CLEANUP_WAITING_WITH_BOTHQ = CLEANUP_WAITING.clone_with_bothq()
1236 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',727
1237 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',
1238 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ',
1239 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',
1240 enter=lambda m: m.action_q.cleanup(),
1241 )
1242
1243START_CLEANUP_WAITING_WITH_BOTHQ = SyncDaemonState(
1244 'START_CLEANUP_WAITING_WITH_BOTHQ',
1245 'start doing cleanup (network dropped; bothq waiting)',
1246 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1247 'CLEANUP_WAITING_WITH_BOTHQ',
1248 'CLEANUP_WAITING_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ',
1249 'CLEANUP_WAITING_WITH_BOTHQ',
1250 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_BOTHQ',
1251 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
1252 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
1253 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ',
1254 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_METAQ',
1255 enter=lambda m: m.action_q.cleanup(),
1256 )
1257
1258CLEANUP_WAITING = SyncDaemonState(
1259 'CLEANUP_WAITING',
1260 'doing cleanup (network dropped)',
1261 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING',
1262 'CLEANUP_WAITING', 'CLEANUP', 'CLEANUP_WAITING',
1263 SYS_CLEANUP_STARTED='CLEANUP_WAITING',
1264 SYS_CLEANUP_FINISHED='READY_WAITING',
1265 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ',
1266 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',
1267 SYS_META_QUEUE_DONE='CLEANUP_WAITING',
1268 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',
1269 )
1270
1271CLEANUP_WAITING_WITH_METAQ = SyncDaemonState(
1272 'CLEANUP_WAITING_WITH_METAQ',
1273 'doing cleanup (network dropped, meta_q waiting)',
1274 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', 'CLEANUP_WAITING_WITH_METAQ',
1275 'CLEANUP_WAITING_WITH_METAQ', 'CLEANUP_WITH_METAQ',
1276 'CLEANUP_WAITING_WITH_METAQ',
1277 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_METAQ',
1278 SYS_CLEANUP_FINISHED='READY_WAITING_WITH_METAQ',
1279 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ',
1280 SYS_META_QUEUE_DONE='CLEANUP_WAITING',
1281 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
1282 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_METAQ',
1283 )
1284
1285CLEANUP_WAITING_WITH_CONTQ = SyncDaemonState(
1286 'CLEANUP_WAITING_WITH_CONTQ',
1287 'doing cleanup (network dropped, content_q waiting)',
1288 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', 'CLEANUP_WAITING_WITH_CONTQ',
1289 'CLEANUP_WAITING_WITH_CONTQ', 'CLEANUP_WITH_CONTQ',
1290 'CLEANUP_WAITING_WITH_CONTQ',
1291 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_CONTQ',
1292 SYS_CLEANUP_FINISHED='READY_WAITING_WITH_CONTQ',
1293 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
1294 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ',
1295 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',
1296 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',
1297 )
1298
1299CLEANUP_WAITING_WITH_BOTHQ = SyncDaemonState(
1300 'CLEANUP_WAITING_WITH_BOTHQ',
1301 'doing cleanup (network dropped, both _q\'s waiting)',
1302 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', 'CLEANUP_WAITING_WITH_BOTHQ',
1303 'CLEANUP_WAITING_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ',
1304 'CLEANUP_WAITING_WITH_BOTHQ',
1305 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_BOTHQ',
1306 SYS_CLEANUP_FINISHED='READY_WAITING_WITH_BOTHQ',
1307 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
1308 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ',
1309 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
1310 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_METAQ',
1311 )
1312728
1313CLEANUP_WITH_NETWORK = SyncDaemonState(729CLEANUP_WITH_NETWORK = SyncDaemonState(
1314 'CLEANUP_WITH_NETWORK',730 'CLEANUP_WITH_NETWORK',
1315 'doing cleanup (net hiccup; user asked for shutdown)',731 'doing cleanup; net hiccup, user asked for shutdown',
1316 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',732 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',
1317 'CLEANUP', 'CLEANUP_WITH_NETWORK', 'CLEANUP_WITH_NETWORK',733 'CLEANUP', 'CLEANUP_WITH_NETWORK',
734 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
1318 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK',735 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK',
736 SYS_CLEANUP_FINISHED='START_STANDOFF_WITH_NETWORK',
737 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ',
738 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',
739 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK',
740 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK',
741 )
742CLEANUP_WITH_NETWORK_WITH_METAQ = CLEANUP_WITH_NETWORK.clone_with_metaq()
743CLEANUP_WITH_NETWORK_WITH_CONTQ = CLEANUP_WITH_NETWORK.clone_with_contq()
744CLEANUP_WITH_NETWORK_WITH_BOTHQ = CLEANUP_WITH_NETWORK.clone_with_bothq()
745
746CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST = SyncDaemonState(
747 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
748 'doing cleanup; net hiccup, user asked to shutdown, '
749 'already got SYS_CONNECTION_LOST',
750 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
751 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
752 'CLEANUP_WITH_CONNECTION_LOST',
753 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
754 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
755 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
1319 SYS_CLEANUP_FINISHED='READY_WITH_NETWORK',756 SYS_CLEANUP_FINISHED='READY_WITH_NETWORK',
1320 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ',757 SYS_META_QUEUE_WAITING=\
1321 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',758 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ',
1322 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK',759 SYS_CONTENT_QUEUE_WAITING=\
1323 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK',760 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ',
1324 )761 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
1325762 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
1326CLEANUP_WITH_NETWORK_WITH_METAQ = SyncDaemonState(763)
1327 'CLEANUP_WITH_NETWORK_WITH_METAQ',764CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ = \
1328 'doing cleanup (net hiccup; user asked for shutdown; meta_q waiting)',765 CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_metaq()
1329 'CLEANUP_WITH_NETWORK_WITH_METAQ',766CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ = \
1330 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',767 CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_contq()
1331 'CLEANUP_WITH_METAQ', 'CLEANUP_WITH_NETWORK_WITH_METAQ',768CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_BOTHQ = \
1332 'CLEANUP_WITH_NETWORK_WITH_METAQ',769 CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_bothq()
1333 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_METAQ',
1334 SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_METAQ',
1335 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ',
1336 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK',
1337 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1338 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_METAQ',
1339 )
1340
1341CLEANUP_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
1342 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
1343 'doing cleanup (net hiccup; user asked for shutdown; content_q waiting)',
1344 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
1345 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1346 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
1347 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
1348 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONTQ',
1349 SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_CONTQ',
1350 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1351 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ',
1352 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',
1353 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK',
1354 )
1355
1356CLEANUP_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
1357 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1358 'doing cleanup (net hiccup; user asked for shutdown; both _q\'s waiting)',
1359 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1360 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1361 'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1362 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1363 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1364 SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_BOTHQ',
1365 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1366 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ',
1367 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1368 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_METAQ',
1369 )
1370770
1371CLEANUP_WAITING_WITH_NETWORK = SyncDaemonState(771CLEANUP_WAITING_WITH_NETWORK = SyncDaemonState(
1372 'CLEANUP_WAITING_WITH_NETWORK',772 'CLEANUP_WAITING_WITH_NETWORK',
1373 'doing cleanup (network hiccup)',773 'doing cleanup; network hiccup',
1374 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',774 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',
1375 'CLEANUP_WAITING', 'CLEANUP_WITH_NETWORK',775 'CLEANUP_WAITING', 'CLEANUP_WITH_NETWORK',
1376 'CLEANUP_WAITING_WITH_NETWORK',776 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
1377 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK',777 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK',
1378 SYS_CLEANUP_FINISHED='START_CONNECTING',778 SYS_CLEANUP_FINISHED='START_STANDOFF_WAITING_WITH_NETWORK',
1379 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',779 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
1380 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',780 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1381 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',781 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
1382 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',782 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
1383 )783 )
1384784CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ = \
1385START_CLEANUP_WAITING_WITH_NETWORK = SyncDaemonState(785 CLEANUP_WAITING_WITH_NETWORK.clone_with_metaq()
1386 'START_CLEANUP_WAITING_WITH_NETWORK',786CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ = \
1387 'doing cleanup (network hiccup)',787 CLEANUP_WAITING_WITH_NETWORK.clone_with_contq()
1388 'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',788CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ = \
1389 'CLEANUP_WAITING', 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',789 CLEANUP_WAITING_WITH_NETWORK.clone_with_bothq()
1390 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK',790
1391 SYS_CLEANUP_FINISHED='START_CONNECTING',791START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST = SyncDaemonState(
1392 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',792 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
1393 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',793 'start doing cleanup; network hiccup, already got SYS_CONNECTION_LOST',
1394 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',794 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
1395 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',795 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
1396 enter=lambda m: m.action_q.cleanup(),796 'CLEANUP_WAITING_WITH_CONNECTION_LOST',
1397 )797 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
1398798 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
1399START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(799 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
1400 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',800 SYS_META_QUEUE_WAITING=\
1401 'doing cleanup (network hiccup; cont_q waiting)',801 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ',
1402 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',802 SYS_CONTENT_QUEUE_WAITING=\
1403 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',803 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ',
1404 'CLEANUP_WAITING_WITH_CONTQ',804 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
1405 'CLEANUP_WITH_NETWORK_WITH_CONTQ',805 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
1406 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',806 enter=lambda m: m.action_q.cleanup(),
1407 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',807)
1408 SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_CONTQ',808START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ = \
1409 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',809 START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_contq()
1410 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',810CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST = \
1411 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',811 START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_no_start(
1412 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',812 'doing cleanup; network hiccup, already got SYS_CONNECTION_LOST',
1413 enter=lambda m: m.action_q.cleanup(),813 SYS_CLEANUP_FINISHED='START_CONNECTING')
1414 )814CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ = \
1415815 CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_metaq()
1416START_CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(816CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ = \
1417 'START_CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',817 CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_contq()
1418 'doing cleanup (network hiccup; both _q\'s waiting)',818CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_BOTHQ = \
1419 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',819 CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_bothq()
1420 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',820
1421 'CLEANUP_WAITING_WITH_BOTHQ',821CLEANUP_WAITING_WITH_CONNECTION_LOST = SyncDaemonState(
1422 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',822 'CLEANUP_WAITING_WITH_CONNECTION_LOST',
1423 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',823 'doing cleanup; network down, connection already lost',
1424 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',824 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
1425 SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_BOTHQ',825 'CLEANUP_WAITING_WITH_CONNECTION_LOST',
1426 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',826 'CLEANUP_WAITING_WITH_CONNECTION_LOST',
1427 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',827 'CLEANUP_WITH_CONNECTION_LOST',
1428 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',828 'CLEANUP_WAITING_WITH_CONNECTION_LOST',
1429 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',829 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_CONNECTION_LOST',
1430 enter=lambda m: m.action_q.cleanup(),830 SYS_CLEANUP_FINISHED='READY_WAITING',
1431 )831 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_METAQ',
1432832 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_CONTQ',
1433CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ = SyncDaemonState(833 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONNECTION_LOST',
1434 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',834 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_CONNECTION_LOST',
1435 'doing cleanup (network hiccup; meta_q waiting)',835 )
1436 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',836CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_METAQ = \
1437 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',837 CLEANUP_WAITING_WITH_CONNECTION_LOST.clone_with_metaq()
1438 'CLEANUP_WAITING_WITH_METAQ', 'CLEANUP_WITH_NETWORK_WITH_METAQ',838CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_CONTQ = \
1439 'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',839 CLEANUP_WAITING_WITH_CONNECTION_LOST.clone_with_contq()
1440 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',840CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_BOTHQ = \
1441 SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_METAQ',841 CLEANUP_WAITING_WITH_CONNECTION_LOST.clone_with_bothq()
1442 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
1443 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
1444 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1445 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
1446 )
1447
1448CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
1449 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1450 'doing cleanup (network hiccup; content_q waiting)',
1451 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1452 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1453 'CLEANUP_WAITING_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
1454 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1455 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1456 SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_CONTQ',
1457 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1458 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1459 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1460 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
1461 )
1462
1463CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
1464 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1465 'doing cleanup (network hiccup; both _q\'s waiting)',
1466 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1467 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1468 'CLEANUP_WAITING_WITH_BOTHQ', 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1469 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1470 SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1471 SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_BOTHQ',
1472 SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1473 SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1474 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1475 SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
1476 )
1477
1478
1479842
1480# XXX CONNECTED_CLEANUP should use the network to do a "better" cleanup843# XXX CONNECTED_CLEANUP should use the network to do a "better" cleanup
844# XXX the way it stands the cloning methods are useless
1481START_CONNECTED_CLEANUP = SyncDaemonState(845START_CONNECTED_CLEANUP = SyncDaemonState(
1482 'START_CONNECTED_CLEANUP',846 'START_CONNECTED_CLEANUP',
1483 'start doing cleanup using the network'847 'start doing cleanup using the network'
1484 ' (not yet implemented; actually starts a plain cleanup)',848 ' (not yet implemented; actually starts a plain cleanup)',
1485 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',849 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',
1486 'CLEANUP', 'CLEANUP_WITH_NETWORK', 'CLEANUP_WITH_NETWORK',850 'CLEANUP', 'CLEANUP_WITH_NETWORK',
851 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
1487 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK',852 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK',
1488 SYS_CLEANUP_FINISHED='READY_WITH_NETWORK',853 SYS_CLEANUP_FINISHED='START_STANDOFF_WITH_NETWORK',
1489 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ',854 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ',
1490 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',855 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',
1491 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK',856 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK',
@@ -1500,29 +865,12 @@
1500 'CLEANUP_WITH_NETWORK_WITH_CONTQ',865 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
1501 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',866 'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
1502 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ',867 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
1503 'CLEANUP_WITH_NETWORK_WITH_CONTQ',868 'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ',
1504 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONTQ',869 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONTQ',
1505 SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_CONTQ',870 SYS_CLEANUP_FINISHED='START_STANDOFF_WITH_NETWORK_WITH_CONTQ',
1506 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',871 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1507 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ',872 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ',
1508 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',873 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',
1509 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK',874 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK',
1510 enter=lambda m: m.action_q.cleanup(),875 enter=lambda m: m.action_q.cleanup(),
1511 )876 )
1512
1513START_CONNECTED_CLEANUP_WITH_BOTHQ = SyncDaemonState(
1514 'START_CONNECTED_CLEANUP_WITH_BOTHQ',
1515 'start doing cleanup using the network'
1516 ' (not yet implemented; actually starts a plain cleanup)',
1517 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1518 'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
1519 'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1520 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1521 SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1522 SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_BOTHQ',
1523 SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1524 SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ',
1525 SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
1526 SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_METAQ',
1527 enter=lambda m: m.action_q.cleanup(),
1528 )

Subscribers

People subscribed via source and target branches