docs: def _auto_wait_for_status(self, message=None, exclude_services=None,
                                include_only=None, timeout=None):
          """Wait for all units to have a specific extended status, except
          for any defined as excluded.  Unless specified via message, any
          status containing any case of 'ready' will be considered a match.
  
          Examples of message usage:
  
            Wait for all unit status to CONTAIN any case of 'ready' or 'ok':
                message = re.compile('.*ready.*|.*ok.*', re.IGNORECASE)
  
            Wait for all units to reach this status (exact match):
                message = re.compile('^Unit is ready and clustered$')
  
            Wait for all units to reach any one of these (exact match):
                message = re.compile('Unit is ready|OK|Ready')
  
            Wait for at least one unit to reach this status (exact match):
                message = {'ready'}
  
          See Amulet's sentry.wait_for_messages() for message usage detail.
          https://github.com/juju/amulet/blob/master/amulet/sentry.py
  
          :param message: Expected status match
          :param exclude_services: List of juju service names to ignore,
              not to be used in conjuction with include_only.
          :param include_only: List of juju service names to exclusively check,
              not to be used in conjuction with exclude_services.
          :param timeout: Maximum time in seconds to wait for status match
          :returns: None.  Raises if timeout is hit.
          """
          if not timeout:
              timeout = int(os.environ.get('AMULET_SETUP_TIMEOUT', 1800))
          self.log.info('Waiting for extended status on units for {}s...'
                        ''.format(timeout))
  
          all_services = self.d.services.keys()
  
          if exclude_services and include_only:
              raise ValueError('exclude_services can not be used '
                               'with include_only')
  
          if message:
              if isinstance(message, re._pattern_type):
                  match = message.pattern
              else:
                  match = message
  
              self.log.debug('Custom extended status wait match: '
                             '{}'.format(match))
          else:
              self.log.debug('Default extended status wait match:  contains '
                             'READY (case-insensitive)')
              message = re.compile('.*ready.*', re.IGNORECASE)
  
          if exclude_services:
              self.log.debug('Excluding services from extended status match: '
                             '{}'.format(exclude_services))
          else:
              exclude_services = []
  
          if include_only:
              services = include_only
          else:
              services = list(set(all_services) - set(exclude_services))
  
          self.log.debug('Waiting up to {}s for extended status on services: '
                         '{}'.format(timeout, services))
          service_messages = {service: message for service in services}
  
          # Check for idleness
          self.d.sentry.wait(timeout=timeout)
          # Check for error states and bail early
          self.d.sentry.wait_for_status(self.d.juju_env, services, timeout=timeout)
          # Check for ready messages
          self.d.sentry.wait_for_messages(service_messages, timeout=timeout)
  
          self.log.info('OK')