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

[John Lenton]

fixes #420354 (BadTransitions happening due to there being multiple active connections on the client)

[John Lenton (chipaca)]

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.

[Rick McBride (rmcbride)]

LOoks good! very long but it makes sense and tests pass.

review: Approve

[Eric Casteleijn (thisfred)]

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

[John Lenton (chipaca)]

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 :)

[Eric Casteleijn (thisfred)]

> 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! ;)

=== 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 @@
-"""
-This is a sanity checker for the humongous ball of dragonspit that is
-ubuntuone.syncdaemon.states
-"""
-
-import re
-
-from ubuntuone.syncdaemon import states, event_queue
-
-
-all_states = dict((k, v) for (k, v) in vars(states).items()
-                  if isinstance(v, states.SyncDaemonState))
-
-is_start = re.compile(r'(?:^START_|_START(?:_WITH_[^_]+Q)?$)').search
-has_q = re.compile(r'_WITH_([^_]+)Q$|^(?:START_)?WORKING_ON_(....)').search
-
-all_trns = set(sum((state.transitions.values()
-                    for state in all_states.values()), []))
-
-for name, state in sorted(all_states.items()):
-    if name != state.name:
-        # the name of the object and the object's name attribute
-        # should be the same
-        print name, 'says it is called', state.name
-
-    if isinstance(state, states.WorkingSDState):
-        if state.with_q is None and has_q(name):
-            # WorkingSDState instances that have a name such as
-            # FOO_WITH_METAQ should be initialized with with_q='META'
-            print name, 'should have with_q!'
-        elif state.with_q and not name.endswith(state.with_q):
-            print name, 'says it is with_q', state.with_q
-
-    # check the state is 'reachable'
-    if name not in all_trns:
-        print name, 'is not the target of any transition!'
-
-    # check the events and final states mentioned in the transitions
-    # all exist
-    for evt, trn in sorted(state.transitions.items()):
-        if evt not in event_queue.EVENTS:
-            print '%s responds to %s event which 404' % (name, trn)
-        if trn not in all_states:
-            print '%s --[%s]--> %s which 404' % (name, evt, trn)
-
-    if is_start(name):
-        # checks specific to START states
-        if state.enter is None:
-            # a START state with no enter is not a START state at all
-            print name, 'has no enter'
-        other_name = re.sub(r'_START|START_', '', name)
-        if other_name not in all_states:
-            # a START state with no homonymous non-START state?
-            if not name.startswith('START_CONNECTED_CLEANUP'):
-                print name, 'has no non-starter'
-        else:
-            # a START state and its homonymous non-START state should
-            # handle pretty much the same events, and react in similar
-            # ways
-            other = all_states[other_name]
-            this_trn = set(state.transitions)
-            other_trn = set(other.transitions)
-            only_in_this = this_trn - other_trn
-            only_in_other = other_trn - this_trn \
-                - set(['SYS_SERVER_RESCAN_DONE', 'SYS_CLEANUP_FINISHED'])
-            if only_in_this:
-                # an event in the START state is not handled by the non-START
-                print 'missing from %s: %s' % (other_name,
-                                               ", ".join(sorted(only_in_this)))
-            if only_in_other:
-                # viceversa
-                print 'missing from %s: %s' % (name,
-                                               ", ".join(sorted(only_in_other)))
-            for trn in sorted(this_trn.intersection(other_trn)):
-                if state.transitions[trn] != other.transitions[trn]:
-                    # the is handled, but differently
-                    if not (name == state.transitions[trn]
-                             and other.name == other.transitions[trn]):
-                        print '%s pushes %s --> %s, but %s --> %s' % \
-                            (trn, name, state.transitions[trn],
-                             other.name, other.transitions[trn])
-    else:
-        if state.enter is not None:
-            # a non-START state with an enter is actually a START state
-            print name, 'has enter'
-
-    # most states that have a _WITH_<some>Q should have all three
-    has_withq = any((name + '_WITH_' + queue in all_states)
-                    for queue in ('METAQ', 'CONTQ', 'BOTHQ'))
-    if has_withq:
-        for queue in ('METAQ', 'CONTQ', 'BOTHQ'):
-            other_name = name + '_WITH_' + queue
-            if other_name not in all_states:
-                print name, 'has some queues but not', queue
-            else:
-                other = all_states[other_name]
-                this_trn = set(state.transitions)
-                other_trn = set(other.transitions)
-                if this_trn != other_trn:
-                    only_in_this = this_trn - other_trn
-                    only_in_other = other_trn - this_trn
-                    if only_in_this:
-                        print 'missing from %s: %s' % \
-                            (other_name, ", ".join(sorted(only_in_this)))
-                    if only_in_other:
-                        print 'missing from %s: %s' % \
-                            (name, ", ".join(sorted(only_in_other)))
-    # the tuple is SYS_META_QUEUE_WAITING, _DONE, and then _CONTENT_
-    ok_trns = {'meta': ('meta', '', 'both', 'meta'),
-               'cont': ('both', 'cont', 'cont', ''),
-               'both': ('both', 'cont', 'both', 'meta'),
-               '': ('meta', '', 'cont', ''),
-               }
-    if has_q(state.name):
-        this_q = filter(None, has_q(state.name).groups())[0].lower()
-    else:
-        this_q = ''
-    for i, evt in enumerate(['SYS_META_QUEUE_WAITING',
-                             'SYS_META_QUEUE_DONE',
-                             'SYS_CONTENT_QUEUE_WAITING',
-                             'SYS_CONTENT_QUEUE_DONE']):
-        trn = state.transitions.get(evt, None)
-        if trn is None:
-            continue
-        if has_q(trn):
-            that_q = filter(None, has_q(trn).groups())[0].lower()
-        else:
-            that_q = ''
-        if ok_trns[this_q][i] != that_q:
-            print '%s goes to %r on %r instead of %r' % (state.name,
-                                                         trn, evt,
-                                                         ok_trns[this_q][i])
-
-    # most states should handle the queue events
-    if not (isinstance(state, states.AQErrorState)
-            or name == 'INIT'
-            or name.startswith('INIT_')):
-        for event in ['SYS_META_QUEUE_WAITING', 'SYS_META_QUEUE_DONE',
-                      'SYS_CONTENT_QUEUE_WAITING', 'SYS_CONTENT_QUEUE_DONE']:
-            if event not in state.transitions:
-                print name, 'does not handle', event
-

=== 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 @@
                 reactor.callLater(0, d0.callback, None)
 
         main = self.build_main(handshake_timeout=.5)
+        main.action_q.connect = lambda *_: defer.Deferred()
         main.event_q.subscribe(handler)
         d = main.start()
         d.addCallback(lambda _: main.event_q.push('SYS_NET_CONNECTED'))
@@ -154,11 +155,13 @@
                 if the state is ok, pass the test
                 """
                 if main.state.name != 'EXCESSIVE_TIMEOUTS':
-                    d0.errback(Exception('Too many timeouts'))
+                    d0.errback(Exception('Too many timeouts: %d'
+                                         % cls.num_timeouts))
                 else:
                     d0.callback('OK!')
 
         main = self.build_main(handshake_timeout=.1)
+        main.action_q.connect = lambda *_: defer.Deferred()
         main.event_q.subscribe(handler)
         d = main.start()
         d.addCallback(lambda _: main.event_q.push('SYS_NET_CONNECTED'))

=== 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 @@
+"""
+Sanity checks for the humongous ball of dragonspit that is
+ubuntuone.syncdaemon.states
+"""
+import re
+import unittest
+from ubuntuone.syncdaemon import states, event_queue
+
+
+all_states = dict((k, v) for (k, v) in vars(states).items()
+                  if isinstance(v, states.SyncDaemonState))
+all_trns = set(sum((state.transitions.values()
+                    for state in all_states.values()), []))
+
+has_q = re.compile(r'.*_WITH_([^_]+Q)$').search
+
+class TestBasic(unittest.TestCase):
+    """
+    Checks that apply to (nearly) all states
+    """
+    def test_name(self):
+        """
+        Check that the object's name is the same as the name of the object
+        """
+        self.assertEqual(self.name, self.state.name)
+
+    def _test_handle_external_events(self, external_event):
+        """
+        Generic check, that the given external event is handled in some way
+        """
+        self.assertTrue(external_event in self.state.transitions,
+                        "unhandled external event: %s" % external_event)
+
+    def test_handle_sys_net_disconnected(self):
+        """
+        Check SYS_NET_DISCONNECTED is handled
+        """
+        self._test_handle_external_events('SYS_NET_DISCONNECTED')
+
+    def test_handle_sys_net_connected(self):
+        """
+        Check SYS_NET_CONNECTED is handled
+        """
+        self._test_handle_external_events('SYS_NET_CONNECTED')
+
+    def test_handle_sys_connect(self):
+        """
+        Check SYS_CONNECT is handled
+        """
+        self._test_handle_external_events('SYS_CONNECT')
+
+    def test_handle_sys_disconnect(self):
+        """
+        Check SYS_DISCONNECT is handled
+        """
+        self._test_handle_external_events('SYS_DISCONNECT')
+
+    def test_handle_sys_connection_lost(self):
+        """
+        Check SYS_CONNECTION_LOST is handled
+        """
+        self._test_handle_external_events('SYS_CONNECTION_LOST')
+
+    def test_reachable(self):
+        """
+        Check the state is reachable via a transition
+        """
+        self.assertTrue(self.name in all_trns,
+                        "%s is not the target of any transition!" % self.name)
+
+    def test_start_connecting(self):
+        """
+        Check START_CONNECTING is only reached via SYS_CONNECTION_LOST
+        or one of the READY states
+        """
+        for evt, trn in self.state.transitions.items():
+            if ((trn.startswith('START_CONNECTING')
+                 and not (evt == 'SYS_CONNECTION_LOST'
+                          or 'WITH_CONNECTION_LOST' in self.name))
+                and not
+                ((self.name.startswith('READY_WAITING')
+                  and evt == 'SYS_NET_CONNECTED')
+                 or (self.name.startswith('READY_WITH_NETWORK')
+                     and evt == 'SYS_CONNECT')
+                 or (self.name.startswith('READING_WAITING_WITH_NETWORK')
+                     and evt == 'SYS_LOCAL_RESCAN_DONE'))):
+                raise AssertionError('%s --[%s]--> %s, not STANDOFFish'
+                                     % (self.name, evt, trn))
+
+    def test_events_exist(self):
+        """
+        Check the events are known to EventQueue
+        """
+        diff = set(self.state.transitions) - set(event_queue.EVENTS)
+        self.assertFalse(diff, "unknown events: %s" % ", ".join(diff))
+
+    def test_transitions_exist(self):
+        """
+        Check the target states are known
+        """
+        diff = set(self.state.transitions.values()) - set(all_states)
+        self.assertFalse(diff, "unknown transitions: %s" % ", ".join(diff))
+
+    def test_enter_only_on_start(self):
+        """
+        Only START_ states (and UNKNOWN_ERROR) should have an enter function
+        """
+        if self.name != 'UNKNOWN_ERROR':
+            if not self.name.startswith('START_'):
+                if self.state.enter is not None:
+                    raise AssertionError("%s has enter" % self.name)
+
+    def _test_withq_evt_ok(self, evt, exceptions):
+        """
+        Generic check that the different WITH_xxxQ states are sane
+
+        'sane' here means that they follow the general pattern (seen
+        in ok_trns), i.e. that the different queue events move the
+        state correctly. There are exceptions, which can be specified.
+        """
+        if evt not in self.state.transitions:
+            return
+
+        trn = self.state.transitions[evt]
+
+        if has_q(self.name):
+            this_q = filter(None, has_q(self.name).groups())[0].lower()
+        else:
+            this_q = ''
+
+        ok_trns = {'metaq': {'SYS_CONTENT_QUEUE_DONE': 'metaq',
+                             'SYS_CONTENT_QUEUE_WAITING': 'bothq',
+                             'SYS_META_QUEUE_DONE': '',
+                             'SYS_META_QUEUE_WAITING': 'metaq'},
+                   'contq': {'SYS_CONTENT_QUEUE_DONE': '',
+                             'SYS_CONTENT_QUEUE_WAITING': 'contq',
+                             'SYS_META_QUEUE_DONE': 'contq',
+                             'SYS_META_QUEUE_WAITING': 'bothq'},
+                   'bothq': {'SYS_CONTENT_QUEUE_DONE': 'metaq',
+                             'SYS_CONTENT_QUEUE_WAITING': 'bothq',
+                             'SYS_META_QUEUE_DONE': 'contq',
+                             'SYS_META_QUEUE_WAITING': 'bothq'},
+                   '': {'SYS_CONTENT_QUEUE_DONE': '',
+                        'SYS_CONTENT_QUEUE_WAITING': 'contq',
+                        'SYS_META_QUEUE_DONE': '',
+                        'SYS_META_QUEUE_WAITING': 'metaq'},
+                   }
+
+        if has_q(trn):
+            that_q = filter(None, has_q(trn).groups())[0].lower()
+        else:
+            that_q = ''
+        if ok_trns[this_q][evt] != that_q:
+            # a few exceptions exist
+            if (self.name, trn) not in exceptions:
+                raise AssertionError('%s --[%s]--> %s instead of %s'
+                                     % (self.name, evt, trn,
+                                        ok_trns[this_q][evt]))
+    def test_metaq_waiting_evt_ok(self):
+        """
+        Check for correct handling of SYS_META_QUEUE_WAITING
+        """
+        self._test_withq_evt_ok(
+            'SYS_META_QUEUE_WAITING',
+            [('IDLE', 'START_WORKING_ON_METADATA'),
+             ('START_WORKING_ON_BOTH', 'WORKING_ON_BOTH'),
+             ('START_WORKING_ON_CONTENT', 'START_WORKING_ON_BOTH'),
+             ('START_WORKING_ON_METADATA_WITH_CONTQ',
+                                        'WORKING_ON_METADATA_WITH_CONTQ'),
+             ('START_WORKING_ON_METADATA', 'WORKING_ON_METADATA'),
+             ('WORKING_ON_BOTH', 'WORKING_ON_BOTH'),
+             ('WORKING_ON_CONTENT', 'START_WORKING_ON_BOTH'),
+             ('WORKING_ON_METADATA_WITH_CONTQ',
+                                        'WORKING_ON_METADATA_WITH_CONTQ'),
+             ('WORKING_ON_METADATA', 'WORKING_ON_METADATA'),
+             ])
+
+    def test_metaq_done_evt_ok(self):
+        """
+        Check for correct handling of SYS_META_QUEUE_DONE
+        """
+        self._test_withq_evt_ok(
+            'SYS_META_QUEUE_DONE',
+            [('START_WORKING_ON_METADATA_WITH_CONTQ',
+                                        'START_WORKING_ON_CONTENT'),
+             ('WORKING_ON_METADATA_WITH_CONTQ', 'START_WORKING_ON_CONTENT'),
+             ])
+
+    def test_contq_waiting_ok(self):
+        """
+        Check for correct handling of SYS_CONTENT_QUEUE_WAITING
+        """
+        self._test_withq_evt_ok(
+            'SYS_CONTENT_QUEUE_WAITING',
+            [('IDLE', 'START_WORKING_ON_CONTENT'),
+             ('START_WORKING_ON_BOTH', 'WORKING_ON_BOTH'),
+             ('START_WORKING_ON_CONTENT', 'WORKING_ON_CONTENT'),
+             ('WORKING_ON_BOTH', 'WORKING_ON_BOTH'),
+             ('WORKING_ON_CONTENT', 'WORKING_ON_CONTENT'),
+             ])
+
+    def test_contq_done_ok(self):
+        """
+        Check for correct handling of SYS_CONTENT_QUEUE_DONE
+        """
+        self._test_withq_evt_ok('SYS_CONTENT_QUEUE_DONE', [])
+
+    def test_non_network_transition_leaves_network_alone(self):
+        """
+        Check that the non-network events affect the network state
+
+        network events are SYS_NET_CONNECTED and SYS_NET_DISCONNECTED
+        """
+        bad = []
+        tpl = "%s.has_network is %s but -[%s]->%s.has_network is %s"
+        for evt, trn in self.state.transitions.items():
+            if evt in ('SYS_NET_CONNECTED', 'SYS_NET_DISCONNECTED'):
+                continue
+            trn = all_states[trn]
+            if self.state.has_network != trn.has_network and not trn.is_error:
+                bad.append(tpl % (self.state.name,
+                                  self.state.has_network,
+                                  evt, trn.name,
+                                  trn.has_network))
+        self.assertFalse(bad, ";\n".join(bad))
+
+    def test_network_transition_changes_network_state(self):
+        """
+        Check that network events affect the network state
+        """
+        connected = self.state.transitions['SYS_NET_CONNECTED']
+        disconnected = self.state.transitions['SYS_NET_DISCONNECTED']
+        if not self.state.is_error:
+            self.assertTrue(all_states[connected].has_network)
+        else:
+            self.assertFalse(all_states[connected].has_network)
+        self.assertFalse(all_states[disconnected].has_network)
+
+    def test_non_volitional_transition_leaves_volition_alone(self):
+        """
+        Check that non-volitional events leave the volition alone
+
+        Volitional events are SYS_CONNECT and SYS_DISCONNECT
+        """
+        bad = []
+        tpl = "%s.wants_to_connect is %s but -[%s]->%s.wants_to_connect is %s"
+        for evt, trn in self.state.transitions.items():
+            if evt in ('SYS_CONNECT', 'SYS_DISCONNECT'):
+                continue
+            trn = all_states[trn]
+            if self.state.wants_to_connect != trn.wants_to_connect and not trn.is_error:
+                bad.append(tpl % (self.state.name,
+                                  self.state.wants_to_connect,
+                                  evt, trn.name,
+                                  trn.wants_to_connect))
+        self.assertFalse(bad, ";\n".join(bad))
+
+
+class TestWithQ:
+    """
+    Checks for states with a given with_q
+    """
+    def get_thisq(self):
+        """
+        Get the queue of the current state (from the state's name)
+        """
+        m = has_q(self.state.name)
+        if m is None:
+            return None
+        return filter(None, m.groups())[0]
+
+    def test_withq(self):
+        """
+        Test the queue specified via with_q and the state's name match
+        """
+        if self.state.with_q is None and has_q(self.name):
+            raise AssertionError('%s should have with_q %s, has None'
+                                 % (self.name, self.get_thisq()))
+        elif self.state.with_q != self.get_thisq():
+            raise AssertionError("%s's name imples with_q %s, has %s"
+                                 % (self.name, self.get_thisq(),
+                                    self.state.with_q))
+
+    def test_another_withq(self):
+        """
+        Test that states with one of the with_q's have the others.
+
+        Some exceptions exist.
+        """
+        this_q = self.get_thisq() or ''
+        is_ok = ((this_q == '' and self.state.with_q is None)
+                 or (this_q.upper() == self.state.with_q))
+        if not is_ok:
+            if (self.name, this_q, self.state.with_q) not in [
+                ('START_WORKING_ON_CONTENT', 'cont', None),
+                ('START_WORKING_ON_METADATA', 'meta', None),
+                ('WORKING_ON_CONTENT', 'cont', None),
+                ('WORKING_ON_METADATA', 'meta', None),
+                ]:
+                raise AssertionError(
+                    "%s's name implies %s, but attribute is %r"
+                    % (self.name, this_q or 'noQ', self.state.with_q))
+
+
+class TestCleanupWithConnectionLost:
+    """
+    Checks for CLEANUP states that have already seen SYS_CONNECTION_LOST
+    """
+    def test_cleanup_with_connection_lost(self):
+        """
+        CLEANUP_WITH_CONNECTION_LOST states have already gotten their
+        CONNECTION_LOST, so they don't need to wait for it; they need
+        to not wait for it, instead.
+        """
+        if self.name.startswith('START_'):
+            name = self.name[6:]
+        else:
+            name = self.name
+        target = self.state.transitions['SYS_CONNECTION_LOST']
+        self.assertEqual(name, target)
+
+class TestCleanupPlain:
+    """
+    Tests for CLEANUP states that have not yet seen SYS_CONNECTION_LOST
+    """
+    def test_cleanup_plain_on_connection_lost(self):
+        """
+        When the CONNECTION_LOST events come in, "plain" cleanup states
+        need to go to the sibling CLEANUP_WITH_CONNECTION_LOST
+        """
+        evt = 'SYS_CONNECTION_LOST'
+        trn = self.state.transitions[evt]
+        expected = self.name
+        # start transitions don't transition to self
+        expected = re.sub(r'^START_', '', expected)
+        expected = re.sub(r'^CONNECTED_CLEANUP',
+                          'CLEANUP_WITH_NETWORK', expected)
+        expected = re.sub(r'(.*?)((?:_WITH_(?:CONT|META|BOTH)Q)?)$',
+                          r'\1_WITH_CONNECTION_LOST\2',
+                          expected)
+        self.assertEqual(trn, expected,
+                         '%s --[%s]--> %s, should be %s'
+                         % (self.name, evt, trn, expected))
+
+class TestCleanupNonStarter:
+    """
+    Test for CLEANUP states that are not START_ states
+    """
+    def test_cleanup_on_cleanup_done(self):
+        """
+        Test non-START_ CLEANUP states handle SYS_CLEANUP_FINISHED
+        appropriately
+        """
+        self.assertTrue('SYS_CLEANUP_FINISHED' in self.state.transitions,
+                        '%s should handle SYS_CLEANUP_FINISHED' % self.name)
+        evt = 'SYS_CLEANUP_FINISHED'
+        trn = self.state.transitions[evt]
+        self.assertTrue(trn.startswith('START_STANDOFF'),
+                        '%s --[%s]--> %s, should be START_STANDOFFish'
+                        % (self.name, evt, trn))
+
+class TestStarter:
+    """
+    Tests for START_ states
+    """
+    def setUp(self):
+        """
+        Common set-up code
+        """
+        self.other_name = re.sub(r'^START_', '', self.name)
+        self.other = all_states.get(self.other_name, None)
+        if self.other is not None:
+            self.this_trn = set(self.state.transitions)
+            self.other_trn = set(self.other.transitions)
+            self.only_in_this = self.this_trn - self.other_trn
+            self.only_in_other = self.other_trn - self.this_trn \
+                - set(['SYS_SERVER_RESCAN_DONE', 'SYS_CLEANUP_FINISHED'])
+
+    def test_starters_have_enter(self):
+        """
+        All START_ states should have an enter function
+        """
+        self.assertTrue(self.state.enter is not None,
+                        '%s should have an enter function' % self.name)
+
+    def test_other_exists(self):
+        """
+        All START_ states should have a non-START_ state
+        """
+        self.assertTrue(self.other_name in all_states,
+                        '%s has no non-starter' % self.name)
+
+    def test_no_events_only_in_this(self):
+        """
+        All START_ states need to handle the same events as their
+        non-START_ counterparts
+        """
+        if self.other is None:
+            raise AssertionError('missing non-starter, unable to test')
+        self.assertFalse(
+            self.only_in_this,
+            # an event in the START state is not handled by the non-START
+            'missing from %s: %s' % (self.other_name,
+                                     ", ".join(sorted(self.only_in_this))))
+
+    def test_no_events_only_in_other(self):
+        """
+        in general, non-START_ states need to handle the same events
+        as their START_ counterparts
+        """
+        if self.other is None:
+            raise AssertionError('missing non-starter, unable to test')
+        self.assertFalse(
+          self.only_in_other,
+          'missing from %s: %s' % (self.name,
+                                   ", ".join(sorted(self.only_in_other))))
+
+    def test_same_transitions(self):
+        """
+        in general, the transition dict for START_ and non-START_
+        states should be the same
+        """
+        if self.other is None:
+            raise AssertionError('missing non-starter, unable to test')
+        bad = ['%s pushes %s --> %s, but %s --> %s'
+               % (trn, self.name, self.state.transitions[trn],
+                  self.other.name, self.other.transitions[trn])
+               for trn in sorted(self.this_trn.intersection(self.other_trn))
+               if (self.state.transitions[trn] != self.other.transitions[trn]
+                   and not (self.name == self.state.transitions[trn] and
+                            self.other.name == self.other.transitions[trn]))]
+        self.assertFalse(bad, bad)
+
+
+class TestOtherQ:
+    """
+    Test for states that have _WITH_fooQ states
+    """
+    def _test_other_queues(self, queue, exceptions):
+        """
+        Check that a WITH_fooQ state exists for the given queue (with
+        the given exceptions). Further, check that if it does indeed
+        exist, it handles the same transitions.
+        """
+        other_name = self.name + '_WITH_' + queue
+        if other_name not in all_states:
+            if self.name not in exceptions:
+                raise AssertionError('%s has some queues but not %s'
+                                     % (self.name, queue))
+        else:
+            other = all_states[other_name]
+            this_trn = set(self.state.transitions)
+            other_trn = set(other.transitions)
+            if this_trn != other_trn:
+                only_in_this = this_trn - other_trn
+                only_in_other = other_trn - this_trn
+                if only_in_this:
+                    raise AssertionError('missing from %s: %s' %
+                                         (other_name,
+                                          ", ".join(sorted(only_in_this))))
+                if only_in_other:
+                    raise AssertionError('missing from %s: %s' %
+                                         (self.name,
+                                          ", ".join(sorted(only_in_other))))
+
+    def test_other_meta_queue(self):
+        """
+        Check that a WITH_METAQ state exists for the current state
+        (with exceptions). Further, check that if it does indeed
+        exist, it handles the same transitions as the base state.
+        """
+        self._test_other_queues('METAQ', [
+                'START_CLEANUP_WAITING',
+                'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+                'START_CONNECTED_CLEANUP',
+                'START_WORKING_ON_METADATA',
+                'WORKING_ON_METADATA',
+                ])
+
+    def test_other_cont_queue(self):
+        """
+        Check that a WITH_CONTQ state exists for the current state
+        (with exceptions). Further, check that if it does indeed
+        exist, it handles the same transitions as the base state.
+        """
+        self._test_other_queues('CONTQ', [])
+
+    def test_other_both_queue(self):
+        """
+        Check that a WITH_BOTHQ state exists for the current state
+        (with exceptions). Further, check that if it does indeed
+        exist, it handles the same transitions as the base state.
+        """
+        self._test_other_queues('BOTHQ', [
+                'START_CLEANUP_WAITING',
+                'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+                'START_CONNECTED_CLEANUP',
+                'START_WORKING_ON_METADATA',
+                'WORKING_ON_METADATA',
+                ])
+
+
+class TestHandleQueues:
+    """
+    Tests for handling of queue events
+    """
+    def _test_handles_queue_event(self, queue_event):
+        """
+        Generic test that the current state handles the given queue event
+        """
+        self.assertTrue(queue_event in self.state.transitions,
+                        self.name + ' does not handle ' + queue_event)
+
+    def test_handles_meta_queue_waiting(self):
+        """
+        Check SYS_META_QUEUE_WAITING is handled
+        """
+        self._test_handles_queue_event('SYS_META_QUEUE_WAITING')
+
+    def test_handles_content_queue_waiting(self):
+        """
+        Check SYS_CONTENT_QUEUE_WAITING is handled
+        """
+        self._test_handles_queue_event('SYS_CONTENT_QUEUE_WAITING')
+
+    def test_handles_meta_queue_done(self):
+        """
+        Check SYS_META_QUEUE_DONE is handled
+        """
+        self._test_handles_queue_event('SYS_META_QUEUE_DONE')
+
+    def test_handles_content_queue_done(self):
+        """
+        Check SYS_CONTENT_QUEUE_DONE is handled
+        """
+        self._test_handles_queue_event('SYS_CONTENT_QUEUE_DONE')
+
+
+def test_suite():
+    """
+    Build the test suite
+    """
+    suite = unittest.TestSuite()
+    loader = unittest.TestLoader()
+    flag = object()
+    for name, state in all_states.items():
+        bases = [TestBasic]
+        if getattr(state, 'with_q', flag) is not flag:
+            bases.append(TestWithQ)
+        if re.search('CLEANUP.*WITH_CONNECTION_LOST', name):
+            bases.append(TestCleanupWithConnectionLost)
+        elif 'CLEANUP' in name:
+            bases.append(TestCleanupPlain)
+            if name.startswith('CLEANUP'):
+                bases.append(TestCleanupNonStarter)
+        if name.startswith('START_'):
+            if not name.startswith('START_CONNECTED_CLEANUP'):
+                # CONNECTED_CLEANUP doesn't exist;
+                # we fake it with CLEANUP_WITH_NETWORK
+                bases.append(TestStarter)
+        if any((name + '_WITH_' + queue in all_states)
+               for queue in ('METAQ', 'CONTQ', 'BOTHQ')):
+            bases.append(TestOtherQ)
+        if not (isinstance(state, states.AQErrorState)
+                or name == 'INIT'
+                or name.startswith('INIT_')):
+            bases.append(TestHandleQueues)
+        bases = tuple(reversed(bases))
+        test = type('Test_'+name, bases, {'name': name, 'state': state})
+        suite.addTest(loader.loadTestsFromTestCase(test))
+    return suite

=== 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 @@
     """
     connection_state = 'disconnected'
     factory = None
+    _finished = False
 
     def connectionMade(self):
         """
         Called when a new connection is made.
         All the state is saved in the factory.
         """
+        if self._finished:
+            # the factory is no longer interested in what we have to say
+            return
         logger.debug("connection made")
         LoggingStorageClient.connectionMade(self)
         self.connection_state = 'connected'
@@ -204,9 +208,13 @@
         """
         Close down the sockets
         """
+        self._finished = True
         logger.debug("disconnected")
         if self.transport is not None:
             self.transport.loseConnection()
+        else:
+            # fake the event
+            self.factory.connectionLost(self, 'Transport is None')
 
     def connectionLost(self, reason=None):
         """
@@ -873,6 +881,9 @@
         if self.client is not None:
             self.client.disconnect()
             self.client = None
+        else:
+            # fake it
+            self.connectionLost(None, 'client is None')
 
     def conectionFailed(self, reason=None):
         """

=== 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 @@
         """
         self.watchdog = None
         self.num_timeouts += 1
-        self.main.action_q.disconnect()
         self.main.event_q.push('SYS_HANDSHAKE_TIMEOUT')
 
     @property

=== 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 @@
 The states of the SyncDaemon
 """
 
+from pprint import pformat
+from inspect import getsource
+from difflib import unified_diff
+
+def compare(this, that):
+    this = vars(this)
+    if this['enter'] is not None:
+        this['enter'] = getsource(this['enter']).strip()
+    that = vars(that)
+    if that['enter'] is not None:
+        that['enter'] = getsource(that['enter']).strip()
+    if this != that:
+        print "\n".join(unified_diff(pformat(this).split('\n'),
+                                     pformat(that).split('\n'),
+                                     'new '+this['name'], 'old'))
+        assert False
+
+
 class BadTransition(Exception):
     """
     An event arrived that the state didn't know how to handle.
@@ -50,6 +68,13 @@
         self.is_connected = is_connected
         self.is_online = is_online
         self.enter = enter
+        self.has_network = any((self.is_connected,
+                                "WITH_NETWORK" in name,
+                                "CONNECTING" in name,
+                                "CONNECTED_CLEANUP" in name))
+        self.wants_to_connect = any((self.is_connected,
+                                     "WAITING" in name,
+                                     "CONNECTING" in name))
         self.is_handshake = 'SYS_HANDSHAKE_TIMEOUT' in other_transitions
         self.transitions = dict(SYS_NET_CONNECTED=sys_net_connected_trn,
                                 SYS_CONNECT=sys_connect_trn,
@@ -74,6 +99,81 @@
             raise BadTransition("State %s can't handle the %s event"
                                 % (self.name, event))
 
+
+    def clone_with_queue(self, qname, **extra_transitions):
+        new_trns = self.transitions.copy()
+        del new_trns['SYS_UNKNOWN_ERROR']
+        suffix = '_WITH_' + qname
+        mqw_trn = new_trns.pop('SYS_META_QUEUE_WAITING')
+        mqd_trn = new_trns.pop('SYS_META_QUEUE_DONE')
+        cqw_trn = new_trns.pop('SYS_CONTENT_QUEUE_WAITING')
+        cqd_trn = new_trns.pop('SYS_CONTENT_QUEUE_DONE')
+        if self.name.startswith('START_'):
+            bq_trn = self.name[6:] + '_WITH_BOTHQ'
+            expected_name = 'START_' + dict(METAQ=mqw_trn,
+                                            CONTQ=cqw_trn, BOTHQ=bq_trn)[qname]
+        else:
+            bq_trn = self.name + '_WITH_BOTHQ'
+            expected_name = dict(METAQ=mqw_trn,
+                                 CONTQ=cqw_trn, BOTHQ=bq_trn)[qname]
+        mqw = dict(METAQ=mqw_trn, CONTQ=bq_trn, BOTHQ=bq_trn)[qname]
+        mqd = dict(METAQ=mqd_trn, CONTQ=cqw_trn, BOTHQ=cqw_trn)[qname]
+        cqw = dict(METAQ=bq_trn, CONTQ=cqw_trn, BOTHQ=bq_trn)[qname]
+        cqd = dict(METAQ=mqw_trn, CONTQ=cqd_trn, BOTHQ=mqw_trn)[qname]
+        new = SyncDaemonState(self.name + suffix,
+                              self.description + ', ' + qname + ' waiting',
+                              new_trns.pop('SYS_NET_CONNECTED') + suffix,
+                              new_trns.pop('SYS_CONNECT') + suffix,
+                              new_trns.pop('SYS_NET_DISCONNECTED') + suffix,
+                              new_trns.pop('SYS_DISCONNECT') + suffix,
+                              new_trns.pop('SYS_CONNECTION_LOST') + suffix,
+                              self.is_error, self.is_connected, self.is_online,
+                              self.enter,
+                              SYS_META_QUEUE_WAITING=mqw,
+                              SYS_META_QUEUE_DONE=mqd,
+                              SYS_CONTENT_QUEUE_WAITING=cqw,
+                              SYS_CONTENT_QUEUE_DONE=cqd)
+        new.is_handshake = self.is_handshake
+        new.with_q = qname
+        assert new.name == expected_name, "%r != %r" % (new.name, expected_name)
+        for evt, trn in new_trns.items():
+            if trn not in ['BAD_VERSION', 'CAPABILITIES_MISMATCH', 'AUTH_FAILED']:
+                trn = trn + suffix
+            new.transitions[evt] = trn
+        for evt, trn in extra_transitions.items():
+            new.transitions[evt] = trn
+        return new
+
+    def clone_with_metaq(self, **extra_transitions):
+        return self.clone_with_queue('METAQ', **extra_transitions)
+
+    def clone_with_contq(self, **extra_transitions):
+        return self.clone_with_queue('CONTQ', **extra_transitions)
+
+    def clone_with_bothq(self, **extra_transitions):
+        return self.clone_with_queue('BOTHQ', **extra_transitions)
+
+    def clone_with_no_start(self, new_description, **extra_transitions):
+        if not self.name.startswith('START_'):
+            raise ValueError, "Not a START_ transition"
+        name = self.name[6:]
+        new_trns = self.transitions.copy()
+        del new_trns['SYS_UNKNOWN_ERROR']
+        new_trns.update(extra_transitions)
+        new = SyncDaemonState(name,
+                              new_description,
+                              new_trns.pop('SYS_NET_CONNECTED'),
+                              new_trns.pop('SYS_CONNECT'),
+                              new_trns.pop('SYS_NET_DISCONNECTED'),
+                              new_trns.pop('SYS_DISCONNECT'),
+                              new_trns.pop('SYS_CONNECTION_LOST'),
+                              self.is_error, self.is_connected, self.is_online,
+                              None,
+                              **new_trns)
+        if getattr(self, 'with_q', object) is not object:
+            new.with_q = self.with_q
+        return new
+
 class NonActiveConnectedSDState(SyncDaemonState):
     """
     States that handle network disconnections with no cleanup
@@ -84,6 +184,7 @@
         ready_waiting = 'READY_WAITING'
         ready_w_network = 'READY_WITH_NETWORK'
         start_connecting = 'START_CONNECTING'
+        self.with_q = with_q
         if with_q is not None:
             ready_waiting += '_WITH_' + with_q
             ready_w_network += '_WITH_' + with_q
@@ -111,11 +212,15 @@
             suffix = '_WITH_' + with_q
         else:
             suffix = ''
+        if name.startswith('START_'):
+            next_name = name[6:]
+        else:
+            next_name = name
         super(WorkingSDState, self).__init__(
-            name, description, name, name,
+            name, description, next_name, next_name,
             'START_CLEANUP_WAITING' + suffix,
             'START_CONNECTED_CLEANUP' + suffix,
-            'START_CLEANUP_WAITING_WITH_NETWORK' + suffix,
+            'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST' + suffix,
             is_connected=True, is_online=True,
             **other_transitions)
 
@@ -177,42 +282,9 @@
     SYS_CONTENT_QUEUE_WAITING='READING_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='READING',
     )
-
-READING_WITH_METAQ = SyncDaemonState(
-    'READING_WITH_METAQ',
-    'doing local rescan, meta_q waiting',
-    'READING_WITH_NETWORK_WITH_METAQ', 'READING_WAITING_WITH_METAQ',
-    'READING_WITH_METAQ', 'READING_WITH_METAQ', 'READING_WITH_METAQ',
-    SYS_LOCAL_RESCAN_DONE='READY_FOR_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='READING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='READING',
-    SYS_CONTENT_QUEUE_WAITING='READING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WITH_METAQ',
-    )
-
-READING_WITH_CONTQ = SyncDaemonState(
-    'READING_WITH_CONTQ',
-    'doing local rescan, content_q waiting',
-    'READING_WITH_NETWORK_WITH_CONTQ', 'READING_WAITING_WITH_CONTQ',
-    'READING_WITH_CONTQ', 'READING_WITH_CONTQ', 'READING_WITH_CONTQ',
-    SYS_LOCAL_RESCAN_DONE='READY_FOR_NETWORK_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='READING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='READING',
-    )
-
-READING_WITH_BOTHQ = SyncDaemonState(
-    'READING_WITH_BOTHQ',
-    'doing local rescan, both _q\'s waiting',
-    'READING_WITH_NETWORK_WITH_BOTHQ', 'READING_WAITING_WITH_BOTHQ',
-    'READING_WITH_BOTHQ', 'READING_WITH_BOTHQ', 'READING_WITH_BOTHQ',
-    SYS_LOCAL_RESCAN_DONE='READY_FOR_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='READING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WITH_METAQ',
-    )
+READING_WITH_METAQ = READING.clone_with_metaq()
+READING_WITH_CONTQ = READING.clone_with_contq()
+READING_WITH_BOTHQ = READING.clone_with_bothq()
 
 READING_WITH_NETWORK = SyncDaemonState(
     'READING_WITH_NETWORK',
@@ -225,48 +297,9 @@
     SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK',
     )
-
-READING_WITH_NETWORK_WITH_METAQ = SyncDaemonState(
-    'READING_WITH_NETWORK_WITH_METAQ',
-    'doing local rescan; network is available, meta_q waiting',
-    'READING_WITH_NETWORK_WITH_METAQ',
-    'READING_WAITING_WITH_NETWORK_WITH_METAQ',
-    'READING_WITH_METAQ', 'READING_WITH_NETWORK_WITH_METAQ',
-    'READING_WITH_NETWORK_WITH_METAQ',
-    SYS_LOCAL_RESCAN_DONE='READY_WITH_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='READING_WITH_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_DONE='READING_WITH_NETWORK',
-    SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK_WITH_METAQ',
-    )
-
-READING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
-    'READING_WITH_NETWORK_WITH_CONTQ',
-    'doing local rescan; network is available, content_q waiting',
-    'READING_WITH_NETWORK_WITH_CONTQ',
-    'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'READING_WITH_CONTQ', 'READING_WITH_NETWORK_WITH_CONTQ',
-    'READING_WITH_NETWORK_WITH_CONTQ',
-    SYS_LOCAL_RESCAN_DONE='READY_WITH_NETWORK_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK',
-    )
-
-READING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
-    'READING_WITH_NETWORK_WITH_BOTHQ',
-    'doing local rescan; network is available, both _q\'s waiting',
-    'READING_WITH_NETWORK_WITH_BOTHQ',
-    'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'READING_WITH_BOTHQ', 'READING_WITH_NETWORK_WITH_BOTHQ',
-    'READING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_LOCAL_RESCAN_DONE='READY_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WITH_NETWORK_WITH_METAQ',
-    )
+READING_WITH_NETWORK_WITH_METAQ = READING_WITH_NETWORK.clone_with_metaq()
+READING_WITH_NETWORK_WITH_CONTQ = READING_WITH_NETWORK.clone_with_contq()
+READING_WITH_NETWORK_WITH_BOTHQ = READING_WITH_NETWORK.clone_with_bothq()
 
 READING_WAITING = SyncDaemonState(
     'READING_WAITING',
@@ -279,49 +312,13 @@
     SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='READING_WAITING',
     )
-
-READING_WAITING_WITH_METAQ = SyncDaemonState(
-    'READING_WAITING_WITH_METAQ',
-    'doing local rescan; user wants to connect, meta_q waiting',
-    'READING_WAITING_WITH_NETWORK_WITH_METAQ', 'READING_WAITING_WITH_METAQ',
-    'READING_WAITING_WITH_METAQ', 'READING_WITH_METAQ',
-    'READING_WAITING_WITH_METAQ',
-    SYS_LOCAL_RESCAN_DONE='READY_WAITING_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='READING_WAITING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='READING_WAITING',
-    SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_METAQ',
-    )
-
-READING_WAITING_WITH_CONTQ = SyncDaemonState(
-    'READING_WAITING_WITH_CONTQ',
-    'doing local rescan; user wants to connect, content_q waiting',
-    'READING_WAITING_WITH_NETWORK_WITH_CONTQ', 'READING_WAITING_WITH_CONTQ',
-    'READING_WAITING_WITH_CONTQ', 'READING_WITH_CONTQ',
-    'READING_WAITING_WITH_CONTQ',
-    SYS_LOCAL_RESCAN_DONE='READY_WAITING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READING_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WAITING',
-    )
-
-READING_WAITING_WITH_BOTHQ = SyncDaemonState(
-    'READING_WAITING_WITH_BOTHQ',
-    'doing local rescan; user wants to connect, both _q\'s waiting',
-    'READING_WAITING_WITH_NETWORK_WITH_BOTHQ', 'READING_WAITING_WITH_BOTHQ',
-    'READING_WAITING_WITH_BOTHQ', 'READING_WITH_BOTHQ',
-    'READING_WAITING_WITH_BOTHQ',
-    SYS_LOCAL_RESCAN_DONE='READY_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READING_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_METAQ',
-    )
+READING_WAITING_WITH_METAQ = READING_WAITING.clone_with_metaq()
+READING_WAITING_WITH_CONTQ = READING_WAITING.clone_with_contq()
+READING_WAITING_WITH_BOTHQ = READING_WAITING.clone_with_bothq()
 
 READING_WAITING_WITH_NETWORK = SyncDaemonState(
     'READING_WAITING_WITH_NETWORK',
-    'doing local rescan; user wants to connect, and network is available',
+    'doing local rescan; user wants to connect, network is available',
     'READING_WAITING_WITH_NETWORK', 'READING_WAITING_WITH_NETWORK',
     'READING_WAITING', 'READING_WITH_NETWORK',
     'READING_WAITING_WITH_NETWORK',
@@ -331,55 +328,16 @@
     SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK',
     )
-
-READING_WAITING_WITH_NETWORK_WITH_METAQ = SyncDaemonState(
-    'READING_WAITING_WITH_NETWORK_WITH_METAQ',
-    'doing local rescan; user wants to connect, network is available,'
-        ' meta_q waiting',
-    'READING_WAITING_WITH_NETWORK_WITH_METAQ',
-    'READING_WAITING_WITH_NETWORK_WITH_METAQ',
-    'READING_WAITING_WITH_METAQ', 'READING_WITH_NETWORK_WITH_METAQ',
-    'READING_WAITING_WITH_NETWORK_WITH_METAQ',
-    SYS_LOCAL_RESCAN_DONE='START_CONNECTING_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_DONE='READING_WAITING_WITH_NETWORK',
-    SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_METAQ',
-    )
-
-READING_WAITING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
-    'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'doing local rescan; user wants to connect, network is available,'
-        ' content_q waiting',
-    'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'READING_WAITING_WITH_CONTQ', 'READING_WITH_NETWORK_WITH_CONTQ',
-    'READING_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_LOCAL_RESCAN_DONE='START_CONNECTING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK',
-    )
-
-READING_WAITING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
-    'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'doing local rescan; user wants to connect, network is available,'
-        ' both _q\'s waiting',
-    'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'READING_WAITING_WITH_BOTHQ', 'READING_WITH_NETWORK_WITH_BOTHQ',
-    'READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_LOCAL_RESCAN_DONE='START_CONNECTING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READING_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READING_WAITING_WITH_NETWORK_WITH_METAQ',
-    )
+READING_WAITING_WITH_NETWORK_WITH_METAQ = \
+    READING_WAITING_WITH_NETWORK.clone_with_metaq()
+READING_WAITING_WITH_NETWORK_WITH_CONTQ = \
+    READING_WAITING_WITH_NETWORK.clone_with_contq()
+READING_WAITING_WITH_NETWORK_WITH_BOTHQ = \
+    READING_WAITING_WITH_NETWORK.clone_with_bothq()
 
 READY_FOR_NETWORK = SyncDaemonState(
     'READY_FOR_NETWORK',
-    'ready to connect as soon as the user says so and the network comes up.',
+    'ready to connect as soon as the user says so and the network comes up',
     'READY_WITH_NETWORK', 'READY_WAITING',
     'READY_FOR_NETWORK', 'READY_FOR_NETWORK', 'READY_FOR_NETWORK',
     SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_METAQ',
@@ -387,49 +345,13 @@
     SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK',
     )
-
-READY_FOR_NETWORK_WITH_METAQ = SyncDaemonState(
-    'READY_FOR_NETWORK_WITH_METAQ',
-    'ready to connect as soon as the user says so and the network comes up.'
-    + ' Meta queue is waiting.',
-    'READY_WITH_NETWORK_WITH_METAQ', 'READY_WAITING_WITH_METAQ',
-    'READY_FOR_NETWORK_WITH_METAQ', 'READY_FOR_NETWORK_WITH_METAQ',
-    'READY_FOR_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_DONE='READY_FOR_NETWORK',
-    SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK_WITH_METAQ',
-    )
-
-READY_FOR_NETWORK_WITH_CONTQ = SyncDaemonState(
-    'READY_FOR_NETWORK_WITH_CONTQ',
-    'ready to connect as soon as the user says so and the network comes up.'
-    + ' Content queue is waiting.',
-    'READY_WITH_NETWORK_WITH_CONTQ', 'READY_WAITING_WITH_CONTQ',
-    'READY_FOR_NETWORK_WITH_CONTQ', 'READY_FOR_NETWORK_WITH_CONTQ',
-    'READY_FOR_NETWORK_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READY_FOR_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK',
-    )
-
-READY_FOR_NETWORK_WITH_BOTHQ = SyncDaemonState(
-    'READY_FOR_NETWORK_WITH_BOTHQ',
-    'ready to connect as soon as the user says so and the network comes up.'
-    + ' Both request queues are waiting.',
-    'READY_WITH_NETWORK_WITH_BOTHQ', 'READY_WAITING_WITH_BOTHQ',
-    'READY_FOR_NETWORK_WITH_BOTHQ', 'READY_FOR_NETWORK_WITH_BOTHQ',
-    'READY_FOR_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READY_FOR_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READY_FOR_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READY_FOR_NETWORK_WITH_METAQ',
-    )
+READY_FOR_NETWORK_WITH_METAQ = READY_FOR_NETWORK.clone_with_metaq()
+READY_FOR_NETWORK_WITH_CONTQ = READY_FOR_NETWORK.clone_with_contq()
+READY_FOR_NETWORK_WITH_BOTHQ = READY_FOR_NETWORK.clone_with_bothq()
 
 READY_WITH_NETWORK = SyncDaemonState(
     'READY_WITH_NETWORK',
-    'ready to connect, network is up, user is yet to push "go"',
+    'ready to connect, network up, user yet to push "go"',
     'READY_WITH_NETWORK', 'START_CONNECTING',
     'READY_FOR_NETWORK', 'READY_WITH_NETWORK', 'READY_WITH_NETWORK',
     SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_METAQ',
@@ -437,42 +359,9 @@
     SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK',
     )
-
-READY_WITH_NETWORK_WITH_METAQ = SyncDaemonState(
-    'READY_WITH_NETWORK_WITH_METAQ',
-    'ready to connect, network up, meta_q waiting, user yet to push "go"',
-    'READY_WITH_NETWORK_WITH_METAQ', 'START_CONNECTING_WITH_METAQ',
-    'READY_FOR_NETWORK_WITH_METAQ', 'READY_WITH_NETWORK_WITH_METAQ',
-    'READY_WITH_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_DONE='READY_WITH_NETWORK',
-    SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK_WITH_METAQ',
-    )
-
-READY_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
-    'READY_WITH_NETWORK_WITH_CONTQ',
-    'ready to connect, network up, content_q waiting, user yet to push "go"',
-    'READY_WITH_NETWORK_WITH_CONTQ', 'START_CONNECTING_WITH_CONTQ',
-    'READY_FOR_NETWORK_WITH_CONTQ', 'READY_WITH_NETWORK_WITH_CONTQ',
-    'READY_WITH_NETWORK_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READY_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK',
-    )
-
-READY_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
-    'READY_WITH_NETWORK_WITH_BOTHQ',
-    'ready to connect, network up, both _q\'s waiting, user yet to push "go"',
-    'READY_WITH_NETWORK_WITH_BOTHQ', 'START_CONNECTING_WITH_BOTHQ',
-    'READY_FOR_NETWORK_WITH_BOTHQ', 'READY_WITH_NETWORK_WITH_BOTHQ',
-    'READY_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READY_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READY_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READY_WITH_NETWORK_WITH_METAQ',
-    )
+READY_WITH_NETWORK_WITH_METAQ = READY_WITH_NETWORK.clone_with_metaq()
+READY_WITH_NETWORK_WITH_CONTQ = READY_WITH_NETWORK.clone_with_contq()
+READY_WITH_NETWORK_WITH_BOTHQ = READY_WITH_NETWORK.clone_with_bothq()
 
 READY_WAITING = SyncDaemonState(
     'READY_WAITING',
@@ -484,42 +373,106 @@
     SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='READY_WAITING',
 )
-
-READY_WAITING_WITH_METAQ = SyncDaemonState(
-    'READY_WAITING_WITH_METAQ',
-    'ready to connect; user said "go", network is down, meta_q waiting',
-    'START_CONNECTING_WITH_METAQ', 'READY_WAITING_WITH_METAQ',
-    'READY_WAITING_WITH_METAQ', 'READY_FOR_NETWORK_WITH_METAQ',
-    'READY_WAITING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='READY_WAITING',
-    SYS_META_QUEUE_WAITING='READY_WAITING_WITH_METAQ',
-    SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READY_WAITING_WITH_METAQ',
-)
-
-READY_WAITING_WITH_CONTQ = SyncDaemonState(
-    'READY_WAITING_WITH_CONTQ',
-    'ready to connect; user said "go", network is down, content_q waiting',
-    'START_CONNECTING_WITH_CONTQ', 'READY_WAITING_WITH_CONTQ',
-    'READY_WAITING_WITH_CONTQ', 'READY_FOR_NETWORK_WITH_CONTQ',
-    'READY_WAITING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READY_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='READY_WAITING',
-)
-
-READY_WAITING_WITH_BOTHQ = SyncDaemonState(
-    'READY_WAITING_WITH_BOTHQ',
-    'ready to connect; user said "go", network is down, both _q\'s waiting',
-    'START_CONNECTING_WITH_BOTHQ', 'READY_WAITING_WITH_BOTHQ',
-    'READY_WAITING_WITH_BOTHQ', 'READY_FOR_NETWORK_WITH_BOTHQ',
-    'READY_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='READY_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='READY_WAITING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='READY_WAITING_WITH_METAQ',
-)
+READY_WAITING_WITH_METAQ = READY_WAITING.clone_with_metaq()
+READY_WAITING_WITH_CONTQ = READY_WAITING.clone_with_contq()
+READY_WAITING_WITH_BOTHQ = READY_WAITING.clone_with_bothq()
+
+START_STANDOFF_WAITING_WITH_NETWORK = SyncDaemonState(
+    'START_STANDOFF_WAITING_WITH_NETWORK',
+    'disconnect and wait for SYS_CONNECTION_LOST, then go on to connect',
+    'STANDOFF_WAITING_WITH_NETWORK', 'STANDOFF_WAITING_WITH_NETWORK',
+    'STANDOFF_WAITING', 'STANDOFF_WITH_NETWORK',
+    'START_CONNECTING',
+    SYS_META_QUEUE_WAITING='STANDOFF_WAITING_WITH_NETWORK_WITH_METAQ',
+    SYS_META_QUEUE_DONE='STANDOFF_WAITING_WITH_NETWORK',
+    SYS_CONTENT_QUEUE_WAITING='STANDOFF_WAITING_WITH_NETWORK_WITH_CONTQ',
+    SYS_CONTENT_QUEUE_DONE='STANDOFF_WAITING_WITH_NETWORK',
+    enter=lambda m: m.action_q.disconnect(),
+)
+START_STANDOFF_WAITING_WITH_NETWORK_WITH_METAQ = \
+    START_STANDOFF_WAITING_WITH_NETWORK.clone_with_metaq()
+START_STANDOFF_WAITING_WITH_NETWORK_WITH_CONTQ = \
+    START_STANDOFF_WAITING_WITH_NETWORK.clone_with_contq()
+START_STANDOFF_WAITING_WITH_NETWORK_WITH_BOTHQ = \
+    START_STANDOFF_WAITING_WITH_NETWORK.clone_with_bothq()
+STANDOFF_WAITING_WITH_NETWORK = \
+    START_STANDOFF_WAITING_WITH_NETWORK.clone_with_no_start(
+    'wait for SYS_CONNECTION_LOST, then go on to connect')
+STANDOFF_WAITING_WITH_NETWORK_WITH_METAQ = \
+    STANDOFF_WAITING_WITH_NETWORK.clone_with_metaq()
+STANDOFF_WAITING_WITH_NETWORK_WITH_CONTQ = \
+    STANDOFF_WAITING_WITH_NETWORK.clone_with_contq()
+STANDOFF_WAITING_WITH_NETWORK_WITH_BOTHQ = \
+    STANDOFF_WAITING_WITH_NETWORK.clone_with_bothq()
+
+START_STANDOFF_WITH_NETWORK = SyncDaemonState(
+    'START_STANDOFF_WITH_NETWORK',
+    'disconnect and wait for SYS_CONNECTION_LOST;'
+        ' network present, but asked not to connect',
+    'STANDOFF_WITH_NETWORK', 'STANDOFF_WAITING_WITH_NETWORK',
+    'STANDOFF', 'STANDOFF_WITH_NETWORK',
+    'READY_WITH_NETWORK',
+    SYS_META_QUEUE_WAITING='STANDOFF_WITH_NETWORK_WITH_METAQ',
+    SYS_META_QUEUE_DONE='STANDOFF_WITH_NETWORK',
+    SYS_CONTENT_QUEUE_WAITING='STANDOFF_WITH_NETWORK_WITH_CONTQ',
+    SYS_CONTENT_QUEUE_DONE='STANDOFF_WITH_NETWORK',
+    enter=lambda m: m.action_q.disconnect(),
+)
+START_STANDOFF_WITH_NETWORK_WITH_METAQ = \
+    START_STANDOFF_WITH_NETWORK.clone_with_metaq()
+START_STANDOFF_WITH_NETWORK_WITH_CONTQ = \
+    START_STANDOFF_WITH_NETWORK.clone_with_contq()
+START_STANDOFF_WITH_NETWORK_WITH_BOTHQ = \
+    START_STANDOFF_WITH_NETWORK.clone_with_bothq()
+STANDOFF_WITH_NETWORK = START_STANDOFF_WITH_NETWORK.clone_with_no_start(
+    'wait for SYS_CONNECTION_LOST; network present, but asked not to connect')
+STANDOFF_WITH_NETWORK_WITH_METAQ = STANDOFF_WITH_NETWORK.clone_with_metaq()
+STANDOFF_WITH_NETWORK_WITH_CONTQ = STANDOFF_WITH_NETWORK.clone_with_contq()
+STANDOFF_WITH_NETWORK_WITH_BOTHQ = STANDOFF_WITH_NETWORK.clone_with_bothq()
+
+START_STANDOFF_WAITING = SyncDaemonState(
+    'START_STANDOFF_WAITING',
+    'disconnect and wait for SYS_CONNECTION_LOST;'
+        ' wanting to connect but no network present',
+    'STANDOFF_WAITING_WITH_NETWORK', 'STANDOFF_WAITING',
+    'STANDOFF_WAITING', 'STANDOFF',
+    'READY_WAITING',
+    SYS_META_QUEUE_WAITING='STANDOFF_WAITING_WITH_METAQ',
+    SYS_META_QUEUE_DONE='STANDOFF_WAITING',
+    SYS_CONTENT_QUEUE_WAITING='STANDOFF_WAITING_WITH_CONTQ',
+    SYS_CONTENT_QUEUE_DONE='STANDOFF_WAITING',
+    enter=lambda m: m.action_q.disconnect(),
+)
+START_STANDOFF_WAITING_WITH_METAQ = START_STANDOFF_WAITING.clone_with_metaq()
+START_STANDOFF_WAITING_WITH_CONTQ = START_STANDOFF_WAITING.clone_with_contq()
+START_STANDOFF_WAITING_WITH_BOTHQ = START_STANDOFF_WAITING.clone_with_bothq()
+STANDOFF_WAITING = START_STANDOFF_WAITING.clone_with_no_start(
+    'wait for SYS_CONNECTION_LOST; wanting to connect but no network present')
+STANDOFF_WAITING_WITH_METAQ = STANDOFF_WAITING.clone_with_metaq()
+STANDOFF_WAITING_WITH_CONTQ = STANDOFF_WAITING.clone_with_contq()
+STANDOFF_WAITING_WITH_BOTHQ = STANDOFF_WAITING.clone_with_bothq()
+
+START_STANDOFF = SyncDaemonState(
+    'START_STANDOFF',
+    'disconnect and wait for SYS_CONNECTION_LOST;'
+        ' no network present, not wanting to connect',
+    'STANDOFF_WITH_NETWORK', 'STANDOFF_WAITING',
+    'STANDOFF', 'STANDOFF',
+    'READY_FOR_NETWORK',
+    SYS_META_QUEUE_WAITING='STANDOFF_WITH_METAQ',
+    SYS_META_QUEUE_DONE='STANDOFF',
+    SYS_CONTENT_QUEUE_WAITING='STANDOFF_WITH_CONTQ',
+    SYS_CONTENT_QUEUE_DONE='STANDOFF',
+    enter=lambda m: m.action_q.disconnect(),
+)
+START_STANDOFF_WITH_METAQ = START_STANDOFF.clone_with_metaq()
+START_STANDOFF_WITH_CONTQ = START_STANDOFF.clone_with_contq()
+START_STANDOFF_WITH_BOTHQ = START_STANDOFF.clone_with_bothq()
+STANDOFF = START_STANDOFF.clone_with_no_start(
+    'wait for SYS_CONNECTION_LOST; no network present, not wanting to connect')
+STANDOFF_WITH_METAQ = STANDOFF.clone_with_metaq()
+STANDOFF_WITH_CONTQ = STANDOFF.clone_with_contq()
+STANDOFF_WITH_BOTHQ = STANDOFF.clone_with_bothq()
 
 START_CONNECTING = SyncDaemonState(
     'START_CONNECTING',
@@ -531,109 +484,18 @@
     SYS_META_QUEUE_DONE='CONNECTING',
     SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='CONNECTING',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
-    enter=lambda m: m.action_q.connect(),
-    )
-
-START_CONNECTING_WITH_METAQ = SyncDaemonState(
-    'START_CONNECTING_WITH_METAQ',
-    'started waiting for the socket to come up; meta_q waiting',
-    'CONNECTING_WITH_METAQ', 'CONNECTING_WITH_METAQ',
-    'READY_WAITING_WITH_METAQ', 'READY_WITH_NETWORK_WITH_METAQ',
-    'START_CONNECTING_WITH_METAQ',
-    SYS_CONNECTION_MADE='START_CONNECTED_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='CONNECTING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CONNECTING',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
-    enter=lambda m: m.action_q.connect(),
-    )
-
-START_CONNECTING_WITH_CONTQ = SyncDaemonState(
-    'START_CONNECTING_WITH_CONTQ',
-    'started waiting for the socket to come up; content_q waiting',
-    'CONNECTING_WITH_CONTQ', 'CONNECTING_WITH_CONTQ',
-    'READY_WAITING_WITH_CONTQ', 'READY_WITH_NETWORK_WITH_CONTQ',
-    'START_CONNECTING_WITH_CONTQ',
-    SYS_CONNECTION_MADE='START_CONNECTED_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTING',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
-    enter=lambda m: m.action_q.connect(),
-    )
-
-START_CONNECTING_WITH_BOTHQ = SyncDaemonState(
-    'START_CONNECTING_WITH_BOTHQ',
-    'started waiting for the socket to come up; both _q\'s waiting',
-    'CONNECTING_WITH_BOTHQ', 'CONNECTING_WITH_BOTHQ',
-    'READY_WAITING_WITH_BOTHQ', 'READY_WITH_NETWORK_WITH_BOTHQ',
-    'START_CONNECTING_WITH_BOTHQ',
-    SYS_CONNECTION_MADE='START_CONNECTED_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
-    enter=lambda m: m.action_q.connect(),
-    )
-
-CONNECTING = SyncDaemonState(
-    'CONNECTING',
-    'waiting for the socket to come up',
-    'CONNECTING', 'CONNECTING',
-    'READY_WAITING', 'READY_WITH_NETWORK', 'START_CONNECTING',
-    SYS_CONNECTION_MADE='START_CONNECTED',
-    SYS_META_QUEUE_WAITING='CONNECTING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CONNECTING',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTING',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
-    )
-
-CONNECTING_WITH_METAQ = SyncDaemonState(
-    'CONNECTING_WITH_METAQ',
-    'waiting for the socket to come up; meta_q waiting',
-    'CONNECTING_WITH_METAQ', 'CONNECTING_WITH_METAQ',
-    'READY_WAITING_WITH_METAQ', 'READY_WITH_NETWORK_WITH_METAQ',
-    'START_CONNECTING_WITH_METAQ',
-    SYS_CONNECTION_MADE='START_CONNECTED_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='CONNECTING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CONNECTING',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
-    )
-
-CONNECTING_WITH_CONTQ = SyncDaemonState(
-    'CONNECTING_WITH_CONTQ',
-    'waiting for the socket to come up; content_q waiting',
-    'CONNECTING_WITH_CONTQ', 'CONNECTING_WITH_CONTQ',
-    'READY_WAITING_WITH_CONTQ', 'READY_WITH_NETWORK_WITH_CONTQ',
-    'START_CONNECTING_WITH_CONTQ',
-    SYS_CONNECTION_MADE='START_CONNECTED_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTING',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
-    )
-
-CONNECTING_WITH_BOTHQ = SyncDaemonState(
-    'CONNECTING_WITH_BOTHQ',
-    'waiting for the socket to come up; both _q\'s waiting',
-    'CONNECTING_WITH_BOTHQ', 'CONNECTING_WITH_BOTHQ',
-    'READY_WAITING_WITH_BOTHQ', 'READY_WITH_NETWORK_WITH_BOTHQ',
-    'START_CONNECTING_WITH_BOTHQ',
-    SYS_CONNECTION_MADE='START_CONNECTED_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CONNECTING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTING_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
-    )
+    SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK',
+    enter=lambda m: m.action_q.connect(),
+    )
+START_CONNECTING_WITH_METAQ = START_CONNECTING.clone_with_metaq()
+START_CONNECTING_WITH_CONTQ = START_CONNECTING.clone_with_contq()
+START_CONNECTING_WITH_BOTHQ = START_CONNECTING.clone_with_bothq()
+
+CONNECTING = START_CONNECTING.clone_with_no_start(
+    'waiting for the socket to come up')
+CONNECTING_WITH_METAQ = CONNECTING.clone_with_metaq()
+CONNECTING_WITH_CONTQ = CONNECTING.clone_with_contq()
+CONNECTING_WITH_BOTHQ = CONNECTING.clone_with_bothq()
 
 START_CONNECTED = NonActiveConnectedSDState(
     'START_CONNECTED',
@@ -644,102 +506,17 @@
     SYS_META_QUEUE_DONE='CONNECTED',
     SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='CONNECTED',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
-    enter=lambda m: m.check_version(),
-    )
-
-START_CONNECTED_WITH_METAQ = NonActiveConnectedSDState(
-    'START_CONNECTED_WITH_METAQ',
-    'socket came up! start checking protocol version; meta_q waiting',
-    with_q='METAQ',
-    SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
-    SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='CONNECTED_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CONNECTED',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
-    enter=lambda m: m.check_version(),
-    )
-
-START_CONNECTED_WITH_CONTQ = NonActiveConnectedSDState(
-    'START_CONNECTED_WITH_CONTQ',
-    'socket came up! start checking protocol version; content_q waiting',
-    with_q='CONTQ',
-    SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
-    SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTED',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
-    enter=lambda m: m.check_version(),
-    )
-
-START_CONNECTED_WITH_BOTHQ = NonActiveConnectedSDState(
-    'START_CONNECTED_WITH_BOTHQ',
-    'socket came up! start checking protocol version both _q\'s waiting',
-    with_q='BOTHQ',
-    SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
-    SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
-    enter=lambda m: m.check_version(),
-    )
-
-CONNECTED = NonActiveConnectedSDState(
-    'CONNECTED',
-    'socket came up! checking protocol version',
-    SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
-    SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES',
-    SYS_META_QUEUE_WAITING='CONNECTED_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CONNECTED',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTED',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
-    )
-
-CONNECTED_WITH_METAQ = NonActiveConnectedSDState(
-    'CONNECTED_WITH_METAQ',
-    'socket came up! checking protocol version; meta_q waiting',
-    with_q='METAQ',
-    SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
-    SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='CONNECTED_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CONNECTED',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
-    )
-
-CONNECTED_WITH_CONTQ = NonActiveConnectedSDState(
-    'CONNECTED_WITH_CONTQ',
-    'socket came up! checking protocol version; content_q waiting',
-    with_q='CONTQ',
-    SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
-    SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTED',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
-    )
-
-CONNECTED_WITH_BOTHQ = NonActiveConnectedSDState(
-    'CONNECTED_WITH_BOTHQ',
-    'socket came up! checking protocol version both _q\'s waiting',
-    with_q='BOTHQ',
-    SYS_PROTOCOL_VERSION_ERROR='BAD_VERSION',
-    SYS_PROTOCOL_VERSION_OK='START_SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CONNECTED_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CONNECTED_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CONNECTED_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
-    )
+    SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK',
+    enter=lambda m: m.check_version(),
+    )
+START_CONNECTED_WITH_METAQ = START_CONNECTED.clone_with_metaq()
+START_CONNECTED_WITH_CONTQ = START_CONNECTED.clone_with_contq()
+START_CONNECTED_WITH_BOTHQ = START_CONNECTED.clone_with_bothq()
+CONNECTED = START_CONNECTED.clone_with_no_start('socket came up!'
+                                                ' checking protocol version')
+CONNECTED_WITH_METAQ = CONNECTED.clone_with_metaq()
+CONNECTED_WITH_CONTQ = CONNECTED.clone_with_contq()
+CONNECTED_WITH_BOTHQ = CONNECTED.clone_with_bothq()
 
 BAD_VERSION = AQErrorState(
     'BAD_VERSION',
@@ -755,102 +532,17 @@
     SYS_META_QUEUE_DONE='SET_CAPABILITIES',
     SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
-    enter=lambda m: m.set_capabilities(),
-    )
-
-START_SET_CAPABILITIES_WITH_METAQ = NonActiveConnectedSDState(
-    'START_SET_CAPABILITIES_WITH_METAQ',
-    'protocol version is OK! start checking capabilities; meta_q waiting',
-    with_q='METAQ',
-    SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
-    SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_METAQ',
-    SYS_META_QUEUE_DONE='SET_CAPABILITIES',
-    SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
-    enter=lambda m: m.set_capabilities(),
-    )
-
-START_SET_CAPABILITIES_WITH_CONTQ = NonActiveConnectedSDState(
-    'START_SET_CAPABILITIES_WITH_CONTQ',
-    'protocol version is OK! start checking capabilities; content_q waiting',
-    with_q='CONTQ',
-    SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
-    SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
-    enter=lambda m: m.set_capabilities(),
-    )
-
-START_SET_CAPABILITIES_WITH_BOTHQ = NonActiveConnectedSDState(
-    'START_SET_CAPABILITIES_WITH_BOTHQ',
-    'protocol version is OK! start checking capabilities; both _q\'s waiting',
-    with_q='BOTHQ',
-    SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
-    SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='START_SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
-    enter=lambda m: m.set_capabilities(),
-    )
-
-SET_CAPABILITIES = NonActiveConnectedSDState(
-    'SET_CAPABILITIES',
-    'capabilities OK, do the auth!',
-    SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
-    SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING',
-    SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_METAQ',
-    SYS_META_QUEUE_DONE='SET_CAPABILITIES',
-    SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
-    )
-
-SET_CAPABILITIES_WITH_METAQ = NonActiveConnectedSDState(
-    'SET_CAPABILITIES_WITH_METAQ',
-    'capabilities OK, do the auth!; meta_q waiting',
-    with_q='METAQ',
-    SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
-    SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_METAQ',
-    SYS_META_QUEUE_DONE='SET_CAPABILITIES',
-    SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
-    )
-
-SET_CAPABILITIES_WITH_CONTQ = NonActiveConnectedSDState(
-    'SET_CAPABILITIES_WITH_CONTQ',
-    'capabilities OK, do the auth!; cont_q waiting',
-    with_q='CONTQ',
-    SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
-    SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
-    )
-
-SET_CAPABILITIES_WITH_BOTHQ = NonActiveConnectedSDState(
-    'SET_CAPABILITIES_WITH_BOTHQ',
-    'capabilities OK, do the auth!; both _q\'s waiting',
-    with_q='BOTHQ',
-    SYS_SET_CAPABILITIES_ERROR='CAPABILITIES_MISMATCH',
-    SYS_SET_CAPABILITIES_OK='START_AUTHENTICATING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='SET_CAPABILITIES_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='SET_CAPABILITIES_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='SET_CAPABILITIES_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
-    )
+    SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK',
+    enter=lambda m: m.set_capabilities(),
+    )
+START_SET_CAPABILITIES_WITH_METAQ = START_SET_CAPABILITIES.clone_with_metaq()
+START_SET_CAPABILITIES_WITH_CONTQ = START_SET_CAPABILITIES.clone_with_contq()
+START_SET_CAPABILITIES_WITH_BOTHQ = START_SET_CAPABILITIES.clone_with_bothq()
+SET_CAPABILITIES = START_SET_CAPABILITIES.clone_with_no_start(
+    'protocol version is OK! checking capabilities')
+SET_CAPABILITIES_WITH_METAQ = SET_CAPABILITIES.clone_with_metaq()
+SET_CAPABILITIES_WITH_CONTQ = SET_CAPABILITIES.clone_with_contq()
+SET_CAPABILITIES_WITH_BOTHQ = SET_CAPABILITIES.clone_with_bothq()
 
 CAPABILITIES_MISMATCH = AQErrorState(
     'CAPABILITIES_MISMATCH',
@@ -860,108 +552,23 @@
 START_AUTHENTICATING = NonActiveConnectedSDState(
     'START_AUTHENTICATING',
     'Start doing the OAuth dance',
-    SYS_OAUTH_OK='SCANNING_START',
-    SYS_OAUTH_ERROR='AUTH_FAILED',
-    SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='AUTHENTICATING',
-    SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
-    enter=lambda m: m.authenticate(),
-    )
-
-START_AUTHENTICATING_WITH_METAQ = NonActiveConnectedSDState(
-    'START_AUTHENTICATING_WITH_METAQ',
-    'Start doing the OAuth dance; meta_q waiting',
-    with_q='METAQ',
-    SYS_OAUTH_OK='SCANNING_START_WITH_METAQ',
-    SYS_OAUTH_ERROR='AUTH_FAILED',
-    SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='AUTHENTICATING',
-    SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
-    enter=lambda m: m.authenticate(),
-    )
-
-START_AUTHENTICATING_WITH_CONTQ = NonActiveConnectedSDState(
-    'START_AUTHENTICATING_WITH_CONTQ',
-    'Start doing the OAuth dance; content_q waiting',
-    with_q='CONTQ',
-    SYS_OAUTH_OK='SCANNING_START_WITH_CONTQ',
-    SYS_OAUTH_ERROR='AUTH_FAILED',
-    SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
-    enter=lambda m: m.authenticate(),
-    )
-
-START_AUTHENTICATING_WITH_BOTHQ = NonActiveConnectedSDState(
-    'START_AUTHENTICATING_WITH_BOTHQ',
-    'Start doing the OAuth dance; both _q\'s waiting',
-    with_q='CONTQ',
-    SYS_OAUTH_OK='SCANNING_START_WITH_BOTHQ',
-    SYS_OAUTH_ERROR='AUTH_FAILED',
-    SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
-    enter=lambda m: m.authenticate(),
-    )
-
-AUTHENTICATING = NonActiveConnectedSDState(
-    'AUTHENTICATING',
-    'Doing the OAuth dance',
-    SYS_OAUTH_OK='SCANNING_START',
-    SYS_OAUTH_ERROR='AUTH_FAILED',
-    SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='AUTHENTICATING',
-    SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING',
-    )
-
-AUTHENTICATING_WITH_METAQ = NonActiveConnectedSDState(
-    'AUTHENTICATING_WITH_METAQ',
-    'Doing the OAuth dance; meta_q waiting',
-    with_q='METAQ',
-    SYS_OAUTH_OK='SCANNING_START_WITH_METAQ',
-    SYS_OAUTH_ERROR='AUTH_FAILED',
-    SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='AUTHENTICATING',
-    SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_METAQ',
-    )
-
-AUTHENTICATING_WITH_CONTQ = NonActiveConnectedSDState(
-    'AUTHENTICATING_WITH_CONTQ',
-    'Doing the OAuth dance; content_q waiting',
-    with_q='CONTQ',
-    SYS_OAUTH_OK='SCANNING_START_WITH_CONTQ',
-    SYS_OAUTH_ERROR='AUTH_FAILED',
-    SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_CONTQ',
-    )
-
-AUTHENTICATING_WITH_BOTHQ = NonActiveConnectedSDState(
-    'AUTHENTICATING_WITH_BOTHQ',
-    'Doing the OAuth dance; both _q\'s waiting',
-    with_q='CONTQ',
-    SYS_OAUTH_OK='SCANNING_START_WITH_BOTHQ',
-    SYS_OAUTH_ERROR='AUTH_FAILED',
-    SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='AUTHENTICATING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='AUTHENTICATING_WITH_METAQ',
-    SYS_HANDSHAKE_TIMEOUT='START_CONNECTING_WITH_BOTHQ',
-    )
+    SYS_OAUTH_OK='START_SCANNING',
+    SYS_OAUTH_ERROR='AUTH_FAILED',
+    SYS_META_QUEUE_WAITING='AUTHENTICATING_WITH_METAQ',
+    SYS_META_QUEUE_DONE='AUTHENTICATING',
+    SYS_CONTENT_QUEUE_WAITING='AUTHENTICATING_WITH_CONTQ',
+    SYS_CONTENT_QUEUE_DONE='AUTHENTICATING',
+    SYS_HANDSHAKE_TIMEOUT='START_STANDOFF_WAITING_WITH_NETWORK',
+    enter=lambda m: m.authenticate(),
+    )
+START_AUTHENTICATING_WITH_METAQ = START_AUTHENTICATING.clone_with_metaq()
+START_AUTHENTICATING_WITH_CONTQ = START_AUTHENTICATING.clone_with_contq()
+START_AUTHENTICATING_WITH_BOTHQ = START_AUTHENTICATING.clone_with_bothq()
+AUTHENTICATING = START_AUTHENTICATING.clone_with_no_start(
+    'Doing the OAuth dance')
+AUTHENTICATING_WITH_METAQ = AUTHENTICATING.clone_with_metaq()
+AUTHENTICATING_WITH_CONTQ = AUTHENTICATING.clone_with_contq()
+AUTHENTICATING_WITH_BOTHQ = AUTHENTICATING.clone_with_bothq()
 
 AUTH_FAILED = AQErrorState(
     'AUTH_FAILED',
@@ -976,8 +583,8 @@
     "Some kind of strange error happened and I can't continue",
     enter=lambda m: m.restart())
 
-SCANNING_START = NonActiveConnectedSDState(
-    'SCANNING_START',
+START_SCANNING = NonActiveConnectedSDState(
+    'START_SCANNING',
     'start doing server rescan',
     SYS_SERVER_RESCAN_STARTING='SCANNING',
     SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ',
@@ -986,89 +593,17 @@
     SYS_CONTENT_QUEUE_DONE='SCANNING',
     enter=lambda m: m.server_rescan(),
     )
-
-SCANNING_START_WITH_METAQ = NonActiveConnectedSDState(
-    'SCANNING_START_WITH_METAQ',
-    'start doing server rescan, meta queue is waiting',
-    with_q='METAQ',
-    SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='SCANNING',
-    SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ',
-    enter=lambda m: m.server_rescan(),
-    )
-
-SCANNING_START_WITH_CONTQ = NonActiveConnectedSDState(
-    'SCANNING_START_WITH_CONTQ',
-    'start doing server rescan, content queue waiting',
-    with_q='CONTQ',
-    SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='SCANNING',
-    enter=lambda m: m.server_rescan(),
-    )
-
-SCANNING_START_WITH_BOTHQ = NonActiveConnectedSDState(
-    'SCANNING_START_WITH_BOTHQ',
-    'start doing server rescan, both request queues waiting',
-    with_q='CONTQ',
-    SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ',
-    enter=lambda m: m.server_rescan(),
-    )
-
-SCANNING = NonActiveConnectedSDState(
-    'SCANNING',
-    'doing server rescan',
-    SYS_SERVER_RESCAN_DONE='IDLE',
-    SYS_SERVER_RESCAN_STARTING='SCANNING',
-    SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='SCANNING',
-    SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='SCANNING',
-    )
-
-SCANNING_WITH_METAQ = NonActiveConnectedSDState(
-    'SCANNING_WITH_METAQ',
-    'doing server rescan, meta queue is waiting',
-    with_q='METAQ',
-    SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA',
-    SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='SCANNING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='SCANNING',
-    SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ',
-    )
-
-SCANNING_WITH_CONTQ = NonActiveConnectedSDState(
-    'SCANNING_WITH_CONTQ',
-    'doing server rescan, content queue waiting',
-    with_q='CONTQ',
-    SYS_SERVER_RESCAN_DONE='START_WORKING_ON_CONTENT',
-    SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='SCANNING',
-    )
-
-SCANNING_WITH_BOTHQ = NonActiveConnectedSDState(
-    'SCANNING_WITH_BOTHQ',
-    'doing server rescan, both request queues waiting',
-    with_q='CONTQ',
-    SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA_WITH_CONTQ',
-    SYS_SERVER_RESCAN_STARTING='SCANNING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='SCANNING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='SCANNING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='SCANNING_WITH_METAQ',
-    )
+START_SCANNING_WITH_METAQ = START_SCANNING.clone_with_metaq()
+START_SCANNING_WITH_CONTQ = START_SCANNING.clone_with_contq()
+START_SCANNING_WITH_BOTHQ = START_SCANNING.clone_with_bothq()
+SCANNING = START_SCANNING.clone_with_no_start('doing server rescan',
+                                              SYS_SERVER_RESCAN_DONE='IDLE')
+SCANNING_WITH_METAQ = SCANNING.clone_with_metaq(
+    SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA')
+SCANNING_WITH_CONTQ = SCANNING.clone_with_contq(
+    SYS_SERVER_RESCAN_DONE='START_WORKING_ON_CONTENT')
+SCANNING_WITH_BOTHQ = SCANNING.clone_with_bothq(
+    SYS_SERVER_RESCAN_DONE='START_WORKING_ON_METADATA_WITH_CONTQ')
 
 IDLE = NonActiveConnectedSDState(
     'IDLE',
@@ -1089,15 +624,8 @@
     SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
     enter=lambda m: m.action_q.meta_queue.run(),
     )
-
-WORKING_ON_METADATA = WorkingSDState(
-    'WORKING_ON_METADATA',
-    'working on metadata',
-    SYS_META_QUEUE_WAITING='WORKING_ON_METADATA',
-    SYS_META_QUEUE_DONE='IDLE',
-    SYS_CONTENT_QUEUE_WAITING='WORKING_ON_METADATA_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
-    )
+WORKING_ON_METADATA = START_WORKING_ON_METADATA.clone_with_no_start(
+    'working on metadata')
 
 START_WORKING_ON_CONTENT = WorkingSDState(
     'START_WORKING_ON_CONTENT',
@@ -1108,15 +636,8 @@
     SYS_CONTENT_QUEUE_DONE='IDLE',
     enter=lambda m: m.action_q.content_queue.run(),
     )
-
-WORKING_ON_CONTENT = WorkingSDState(
-    'WORKING_ON_CONTENT',
-    'working on content',
-    SYS_META_QUEUE_WAITING='START_WORKING_ON_BOTH',
-    SYS_META_QUEUE_DONE='WORKING_ON_CONTENT',
-    SYS_CONTENT_QUEUE_WAITING='WORKING_ON_CONTENT',
-    SYS_CONTENT_QUEUE_DONE='IDLE',
-    )
+WORKING_ON_CONTENT = START_WORKING_ON_CONTENT.clone_with_no_start(
+    'working on content')
 
 START_WORKING_ON_METADATA_WITH_CONTQ = WorkingSDState(
     'START_WORKING_ON_METADATA_WITH_CONTQ',
@@ -1128,364 +649,208 @@
     SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
     enter=lambda m: m.action_q.meta_queue.run(),
     )
-
-WORKING_ON_METADATA_WITH_CONTQ = WorkingSDState(
-    'WORKING_ON_METADATA_WITH_CONTQ',
-    'working on metadata; content work is waiting',
-    with_q='CONTQ',
-    SYS_META_QUEUE_WAITING='WORKING_ON_METADATA_WITH_CONTQ',
-    SYS_META_QUEUE_DONE='START_WORKING_ON_CONTENT',
-    SYS_CONTENT_QUEUE_WAITING='WORKING_ON_METADATA_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
-    )
+WORKING_ON_METADATA_WITH_CONTQ = \
+    START_WORKING_ON_METADATA_WITH_CONTQ.clone_with_no_start(
+    'working on metadata; content work is waiting')
 
 START_WORKING_ON_BOTH = WorkingSDState(
     'START_WORKING_ON_BOTH',
     'start working on both content and metadata',
-    with_q='BOTHQ',
     SYS_META_QUEUE_WAITING='WORKING_ON_BOTH',
     SYS_META_QUEUE_DONE='WORKING_ON_CONTENT',
     SYS_CONTENT_QUEUE_WAITING='WORKING_ON_BOTH',
     SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
     enter=lambda m: m.action_q.meta_queue.run(),
     )
-
-WORKING_ON_BOTH = WorkingSDState(
-    'WORKING_ON_BOTH',
-    'working on both content and metadata',
-    with_q='BOTHQ',
-    SYS_META_QUEUE_WAITING='WORKING_ON_BOTH',
-    SYS_META_QUEUE_DONE='WORKING_ON_CONTENT',
-    SYS_CONTENT_QUEUE_WAITING='WORKING_ON_BOTH',
-    SYS_CONTENT_QUEUE_DONE='WORKING_ON_METADATA',
-    )
+WORKING_ON_BOTH = START_WORKING_ON_BOTH.clone_with_no_start(
+    'working on both content and metadata')
 
 CLEANUP = SyncDaemonState(
     'CLEANUP',
-    'doing cleanup (net down, user asked for shutdown)',
+    'doing cleanup; net down, user asked for shutdown',
     'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING',
-    'CLEANUP', 'CLEANUP', 'CLEANUP',
+    'CLEANUP', 'CLEANUP', 'CLEANUP_WITH_CONNECTION_LOST',
     SYS_CLEANUP_STARTED='CLEANUP',
-    SYS_CLEANUP_FINISHED='READY_FOR_NETWORK',
+    SYS_CLEANUP_FINISHED='START_STANDOFF',
     SYS_META_QUEUE_WAITING='CLEANUP_WITH_METAQ',
     SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONTQ',
     SYS_META_QUEUE_DONE='CLEANUP', # cancelling meta_q.head can do this
     SYS_CONTENT_QUEUE_DONE='CLEANUP', # ditto
     )
-
-CLEANUP_WITH_METAQ = SyncDaemonState(
-    'CLEANUP_WITH_METAQ',
-    'doing cleanup (net down, user asked for shutdown, meta_q waiting)',
-    'CLEANUP_WITH_NETWORK_WITH_METAQ', 'CLEANUP_WAITING_WITH_METAQ',
-    'CLEANUP_WITH_METAQ', 'CLEANUP_WITH_METAQ', 'CLEANUP_WITH_METAQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WITH_METAQ',
-    SYS_CLEANUP_FINISHED='READY_FOR_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CLEANUP',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_METAQ',
-    )
-
-CLEANUP_WITH_CONTQ = SyncDaemonState(
-    'CLEANUP_WITH_CONTQ',
-    'doing cleanup (net down, user asked for shutdown, content_q waiting)',
-    'CLEANUP_WITH_NETWORK_WITH_CONTQ', 'CLEANUP_WAITING_WITH_CONTQ',
-    'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_CONTQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WITH_CONTQ',
-    SYS_CLEANUP_FINISHED='READY_FOR_NETWORK_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP',
-    )
-
-CLEANUP_WITH_BOTHQ = SyncDaemonState(
-    'CLEANUP_WITH_BOTHQ',
-    'doing cleanup (net down, user asked for shutdown, both _q\'s waiting)',
-    'CLEANUP_WITH_NETWORK_WITH_BOTHQ', 'CLEANUP_WAITING_WITH_BOTHQ',
-    'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WITH_BOTHQ',
-    SYS_CLEANUP_FINISHED='READY_FOR_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_METAQ',
-    )
+CLEANUP_WITH_METAQ = CLEANUP.clone_with_metaq()
+CLEANUP_WITH_CONTQ = CLEANUP.clone_with_contq()
+CLEANUP_WITH_BOTHQ = CLEANUP.clone_with_bothq()
+
+CLEANUP_WITH_CONNECTION_LOST = SyncDaemonState(
+    'CLEANUP_WITH_CONNECTION_LOST',
+    'doing cleanup; net down, user asked for shutdown, connection already lost',
+    'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    'CLEANUP_WITH_CONNECTION_LOST',
+    'CLEANUP_WITH_CONNECTION_LOST',
+    'CLEANUP_WITH_CONNECTION_LOST',
+    SYS_CLEANUP_STARTED='CLEANUP_WITH_CONNECTION_LOST',
+    SYS_CLEANUP_FINISHED='START_STANDOFF',
+    SYS_META_QUEUE_WAITING='CLEANUP_WITH_CONNECTION_LOST_WITH_METAQ',
+    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_CONNECTION_LOST_WITH_CONTQ',
+    SYS_META_QUEUE_DONE='CLEANUP_WITH_CONNECTION_LOST',
+    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_CONNECTION_LOST',
+    )
+CLEANUP_WITH_CONNECTION_LOST_WITH_METAQ = \
+    CLEANUP_WITH_CONNECTION_LOST.clone_with_metaq()
+CLEANUP_WITH_CONNECTION_LOST_WITH_CONTQ = \
+    CLEANUP_WITH_CONNECTION_LOST.clone_with_contq()
+CLEANUP_WITH_CONNECTION_LOST_WITH_BOTHQ = \
+    CLEANUP_WITH_CONNECTION_LOST.clone_with_bothq()
 
 START_CLEANUP_WAITING = SyncDaemonState(
     'START_CLEANUP_WAITING',
-    'start doing cleanup (network dropped)',
-    'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING',
-    'CLEANUP_WAITING', 'CLEANUP', 'CLEANUP_WAITING',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',
-    enter=lambda m: m.action_q.cleanup(),
-    )
-
-START_CLEANUP_WAITING_WITH_CONTQ = SyncDaemonState(
-    'START_CLEANUP_WAITING_WITH_CONTQ',
-    'start doing cleanup (network dropped; contq waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_CONTQ', 'CLEANUP_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_CONTQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',
-    enter=lambda m: m.action_q.cleanup(),
-    )
-
-START_CLEANUP_WAITING_WITH_BOTHQ = SyncDaemonState(
-    'START_CLEANUP_WAITING_WITH_BOTHQ',
-    'start doing cleanup (network dropped; bothq waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_METAQ',
-    enter=lambda m: m.action_q.cleanup(),
-    )
-
-CLEANUP_WAITING = SyncDaemonState(
-    'CLEANUP_WAITING',
-    'doing cleanup (network dropped)',
-    'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING',
-    'CLEANUP_WAITING', 'CLEANUP', 'CLEANUP_WAITING',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING',
-    SYS_CLEANUP_FINISHED='READY_WAITING',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',
-    )
-
-CLEANUP_WAITING_WITH_METAQ = SyncDaemonState(
-    'CLEANUP_WAITING_WITH_METAQ',
-    'doing cleanup (network dropped, meta_q waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ', 'CLEANUP_WAITING_WITH_METAQ',
-    'CLEANUP_WAITING_WITH_METAQ', 'CLEANUP_WITH_METAQ',
-    'CLEANUP_WAITING_WITH_METAQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_METAQ',
-    SYS_CLEANUP_FINISHED='READY_WAITING_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_METAQ',
-    )
-
-CLEANUP_WAITING_WITH_CONTQ = SyncDaemonState(
-    'CLEANUP_WAITING_WITH_CONTQ',
-    'doing cleanup (network dropped, content_q waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ', 'CLEANUP_WAITING_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_CONTQ', 'CLEANUP_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_CONTQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_CLEANUP_FINISHED='READY_WAITING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',
-    )
-
-CLEANUP_WAITING_WITH_BOTHQ = SyncDaemonState(
-    'CLEANUP_WAITING_WITH_BOTHQ',
-    'doing cleanup (network dropped, both _q\'s waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ', 'CLEANUP_WAITING_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_BOTHQ', 'CLEANUP_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_CLEANUP_FINISHED='READY_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_METAQ',
-    )
+    'start doing cleanup; network dropped',
+    'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING',
+    'CLEANUP_WAITING', 'CLEANUP',
+    'CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    SYS_CLEANUP_STARTED='CLEANUP_WAITING',
+    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_METAQ',
+    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONTQ',
+    SYS_META_QUEUE_DONE='CLEANUP_WAITING',
+    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING',
+    enter=lambda m: m.action_q.cleanup(),
+    )
+START_CLEANUP_WAITING_WITH_CONTQ = START_CLEANUP_WAITING.clone_with_contq()
+# START_CLEANUP_WAITING_WITH_BOTHQ = START_CLEANUP_WAITING.clone_with_bothq()
+CLEANUP_WAITING = START_CLEANUP_WAITING.clone_with_no_start(
+    'doing cleanup; network dropped',
+    SYS_CLEANUP_FINISHED='START_STANDOFF_WAITING')
+CLEANUP_WAITING_WITH_METAQ = CLEANUP_WAITING.clone_with_metaq()
+CLEANUP_WAITING_WITH_CONTQ = CLEANUP_WAITING.clone_with_contq()
+CLEANUP_WAITING_WITH_BOTHQ = CLEANUP_WAITING.clone_with_bothq()
+
 
 CLEANUP_WITH_NETWORK = SyncDaemonState(
     'CLEANUP_WITH_NETWORK',
-    'doing cleanup (net hiccup; user asked for shutdown)',
+    'doing cleanup; net hiccup, user asked for shutdown',
     'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',
-    'CLEANUP', 'CLEANUP_WITH_NETWORK', 'CLEANUP_WITH_NETWORK',
+    'CLEANUP', 'CLEANUP_WITH_NETWORK',
+    'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
     SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK',
+    SYS_CLEANUP_FINISHED='START_STANDOFF_WITH_NETWORK',
+    SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ',
+    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',
+    SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK',
+    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK',
+    )
+CLEANUP_WITH_NETWORK_WITH_METAQ = CLEANUP_WITH_NETWORK.clone_with_metaq()
+CLEANUP_WITH_NETWORK_WITH_CONTQ = CLEANUP_WITH_NETWORK.clone_with_contq()
+CLEANUP_WITH_NETWORK_WITH_BOTHQ = CLEANUP_WITH_NETWORK.clone_with_bothq()
+
+CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST = SyncDaemonState(
+    'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'doing cleanup; net hiccup, user asked to shutdown, '
+        'already got SYS_CONNECTION_LOST',
+    'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'CLEANUP_WITH_CONNECTION_LOST',
+    'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
+    SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
     SYS_CLEANUP_FINISHED='READY_WITH_NETWORK',
-    SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK',
-    )
-
-CLEANUP_WITH_NETWORK_WITH_METAQ = SyncDaemonState(
-    'CLEANUP_WITH_NETWORK_WITH_METAQ',
-    'doing cleanup (net hiccup; user asked for shutdown; meta_q waiting)',
-    'CLEANUP_WITH_NETWORK_WITH_METAQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    'CLEANUP_WITH_METAQ', 'CLEANUP_WITH_NETWORK_WITH_METAQ',
-    'CLEANUP_WITH_NETWORK_WITH_METAQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_METAQ',
-    SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_METAQ',
-    )
-
-CLEANUP_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
-    'CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    'doing cleanup (net hiccup; user asked for shutdown; content_q waiting)',
-    'CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK',
-    )
-
-CLEANUP_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
-    'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    'doing cleanup (net hiccup; user asked for shutdown; both _q\'s waiting)',
-    'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_METAQ',
-    )
+    SYS_META_QUEUE_WAITING=\
+        'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ',
+    SYS_CONTENT_QUEUE_WAITING=\
+        'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ',
+    SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
+    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
+)
+CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ = \
+    CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_metaq()
+CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ = \
+    CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_contq()
+CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_BOTHQ = \
+    CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_bothq()
 
 CLEANUP_WAITING_WITH_NETWORK = SyncDaemonState(
     'CLEANUP_WAITING_WITH_NETWORK',
-    'doing cleanup (network hiccup)',
+    'doing cleanup; network hiccup',
     'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',
     'CLEANUP_WAITING', 'CLEANUP_WITH_NETWORK',
-    'CLEANUP_WAITING_WITH_NETWORK',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK',
-    SYS_CLEANUP_FINISHED='START_CONNECTING',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
-    )
-
-START_CLEANUP_WAITING_WITH_NETWORK = SyncDaemonState(
-    'START_CLEANUP_WAITING_WITH_NETWORK',
-    'doing cleanup (network hiccup)',
-    'CLEANUP_WAITING_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',
-    'CLEANUP_WAITING', 'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK',
-    SYS_CLEANUP_FINISHED='START_CONNECTING',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
-    enter=lambda m: m.action_q.cleanup(),
-    )
-
-START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
-    'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'doing cleanup (network hiccup; cont_q waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_CONTQ',
-    'CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
-    enter=lambda m: m.action_q.cleanup(),
-    )
-
-START_CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
-    'START_CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'doing cleanup (network hiccup; both _q\'s waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_BOTHQ',
-    'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    enter=lambda m: m.action_q.cleanup(),
-    )
-
-CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ = SyncDaemonState(
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    'doing cleanup (network hiccup; meta_q waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    'CLEANUP_WAITING_WITH_METAQ', 'CLEANUP_WITH_NETWORK_WITH_METAQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_METAQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    )
-
-CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ = SyncDaemonState(
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'doing cleanup (network hiccup; content_q waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_CONTQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
-    )
-
-CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ = SyncDaemonState(
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'doing cleanup (network hiccup; both _q\'s waiting)',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_BOTHQ', 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CLEANUP_FINISHED='START_CONNECTING_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
-    )
-
-
+    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK',
+    SYS_CLEANUP_FINISHED='START_STANDOFF_WAITING_WITH_NETWORK',
+    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ',
+    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
+    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
+    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK',
+    )
+CLEANUP_WAITING_WITH_NETWORK_WITH_METAQ = \
+    CLEANUP_WAITING_WITH_NETWORK.clone_with_metaq()
+CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ = \
+    CLEANUP_WAITING_WITH_NETWORK.clone_with_contq()
+CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ = \
+    CLEANUP_WAITING_WITH_NETWORK.clone_with_bothq()
+
+START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST = SyncDaemonState(
+    'START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'start doing cleanup; network hiccup, already got SYS_CONNECTION_LOST',
+    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    SYS_META_QUEUE_WAITING=\
+        'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ',
+    SYS_CONTENT_QUEUE_WAITING=\
+        'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ',
+    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    enter=lambda m: m.action_q.cleanup(),
+)
+START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ = \
+    START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_contq()
+CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST = \
+    START_CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_no_start(
+    'doing cleanup; network hiccup, already got SYS_CONNECTION_LOST',
+    SYS_CLEANUP_FINISHED='START_CONNECTING')
+CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_METAQ = \
+    CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_metaq()
+CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ = \
+    CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_contq()
+CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_BOTHQ = \
+    CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST.clone_with_bothq()
+
+CLEANUP_WAITING_WITH_CONNECTION_LOST = SyncDaemonState(
+    'CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    'doing cleanup; network down, connection already lost',
+    'CLEANUP_WAITING_WITH_NETWORK_WITH_CONNECTION_LOST',
+    'CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    'CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    'CLEANUP_WITH_CONNECTION_LOST',
+    'CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    SYS_CLEANUP_STARTED='CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    SYS_CLEANUP_FINISHED='READY_WAITING',
+    SYS_META_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_METAQ',
+    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_CONTQ',
+    SYS_META_QUEUE_DONE='CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    SYS_CONTENT_QUEUE_DONE='CLEANUP_WAITING_WITH_CONNECTION_LOST',
+    )
+CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_METAQ = \
+    CLEANUP_WAITING_WITH_CONNECTION_LOST.clone_with_metaq()
+CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_CONTQ = \
+    CLEANUP_WAITING_WITH_CONNECTION_LOST.clone_with_contq()
+CLEANUP_WAITING_WITH_CONNECTION_LOST_WITH_BOTHQ = \
+    CLEANUP_WAITING_WITH_CONNECTION_LOST.clone_with_bothq()
 
 # XXX CONNECTED_CLEANUP should use the network to do a "better" cleanup
+# XXX the way it stands the cloning methods are useless
 START_CONNECTED_CLEANUP = SyncDaemonState(
     'START_CONNECTED_CLEANUP',
     'start doing cleanup using the network'
         ' (not yet implemented; actually starts a plain cleanup)',
     'CLEANUP_WITH_NETWORK', 'CLEANUP_WAITING_WITH_NETWORK',
-    'CLEANUP', 'CLEANUP_WITH_NETWORK', 'CLEANUP_WITH_NETWORK',
+    'CLEANUP', 'CLEANUP_WITH_NETWORK',
+    'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST',
     SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK',
-    SYS_CLEANUP_FINISHED='READY_WITH_NETWORK',
+    SYS_CLEANUP_FINISHED='START_STANDOFF_WITH_NETWORK',
     SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_METAQ',
     SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',
     SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK',
@@ -1500,29 +865,12 @@
     'CLEANUP_WITH_NETWORK_WITH_CONTQ',
     'CLEANUP_WAITING_WITH_NETWORK_WITH_CONTQ',
     'CLEANUP_WITH_CONTQ', 'CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    'CLEANUP_WITH_NETWORK_WITH_CONTQ',
+    'CLEANUP_WITH_NETWORK_WITH_CONNECTION_LOST_WITH_CONTQ',
     SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_CONTQ',
+    SYS_CLEANUP_FINISHED='START_STANDOFF_WITH_NETWORK_WITH_CONTQ',
     SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
     SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ',
     SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_CONTQ',
     SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK',
     enter=lambda m: m.action_q.cleanup(),
     )
-
-START_CONNECTED_CLEANUP_WITH_BOTHQ = SyncDaemonState(
-    'START_CONNECTED_CLEANUP_WITH_BOTHQ',
-    'start doing cleanup using the network'
-        ' (not yet implemented; actually starts a plain cleanup)',
-    'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WAITING_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WITH_BOTHQ', 'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    'CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CLEANUP_STARTED='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CLEANUP_FINISHED='READY_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_META_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_CONTQ',
-    SYS_CONTENT_QUEUE_WAITING='CLEANUP_WITH_NETWORK_WITH_BOTHQ',
-    SYS_CONTENT_QUEUE_DONE='CLEANUP_WITH_NETWORK_WITH_METAQ',
-    enter=lambda m: m.action_q.cleanup(),
-    )