docs: def start(transport='zmq',
            address='0.0.0.0',
            port=49017,
            auth_address='0.0.0.0',
            auth_port=49018,
            disable_security=False,
            certificate=None,
            os_whitelist=None,
            os_blacklist=None,
            error_whitelist=None,
            error_blacklist=None,
            host_whitelist=None,
            host_blacklist=None):
      '''
      Listen to napalm-logs and publish events into the Salt event bus.
  
      transport: ``zmq``
          Choose the desired transport.
  
          .. note::
              Currently ``zmq`` is the only valid option.
  
      address: ``0.0.0.0``
          The address of the publisher, as configured on napalm-logs.
  
      port: ``49017``
          The port of the publisher, as configured on napalm-logs.
  
      auth_address: ``0.0.0.0``
          The address used for authentication
          when security is not disabled.
  
      auth_port: ``49018``
          Port used for authentication.
  
      disable_security: ``False``
          Trust unencrypted messages.
          Strongly discouraged in production.
  
      certificate: ``None``
          Absolute path to the SSL certificate.
  
      os_whitelist: ``None``
          List of operating systems allowed. By default everything is allowed.
  
      os_blacklist: ``None``
          List of operating system to be ignored. Nothing ignored by default.
  
      error_whitelist: ``None``
          List of errors allowed.
  
      error_blacklist: ``None``
          List of errors ignored.
  
      host_whitelist: ``None``
          List of hosts or IPs to be allowed.
  
      host_blacklist: ``None``
          List of hosts of IPs to be ignored.
      '''
      if not disable_security:
          if not certificate:
              log.critical('Please use a certificate, or disable the security.')
              return
          auth = napalm_logs.utils.ClientAuth(certificate,
                                              address=auth_address,
                                              port=auth_port)
  
      transport_recv_fun = _get_transport_recv(name=transport,
                                               address=address,
                                               port=port)
      if not transport_recv_fun:
          log.critical('Unable to start the engine', exc_info=True)
          return
      master = False
      if __opts__['__role'] == 'master':
          master = True
      while True:
          log.debug('Waiting for napalm-logs to send anything...')
          raw_object = transport_recv_fun()
          log.debug('Received from napalm-logs:')
          log.debug(raw_object)
          if not disable_security:
              dict_object = auth.decrypt(raw_object)
          else:
              dict_object = napalm_logs.utils.unserialize(raw_object)
          try:
              event_os = dict_object['os']
              if os_blacklist or os_whitelist:
                  valid_os = salt.utils.stringutils.check_whitelist_blacklist(
                      event_os,
                      whitelist=os_whitelist,
                      blacklist=os_blacklist)
                  if not valid_os:
                      log.info('Ignoring NOS %s as per whitelist/blacklist', event_os)
                      continue
              event_error = dict_object['error']
              if error_blacklist or error_whitelist:
                  valid_error = salt.utils.stringutils.check_whitelist_blacklist(
                      event_error,
                      whitelist=error_whitelist,
                      blacklist=error_blacklist)
                  if not valid_error:
                      log.info('Ignoring error %s as per whitelist/blacklist', event_error)
                      continue
              event_host = dict_object.get('host') or dict_object.get('ip')
              if host_blacklist or host_whitelist:
                  valid_host = salt.utils.stringutils.check_whitelist_blacklist(
                      event_host,
                      whitelist=host_whitelist,
                      blacklist=host_blacklist)
                  if not valid_host:
                      log.info('Ignoring messages from %s as per whitelist/blacklist', event_host)
                      continue
              tag = 'napalm/syslog/{os}/{error}/{host}'.format(
                  os=event_os,
                  error=event_error,
                  host=event_host
              )
          except KeyError as kerr:
              log.warning('Missing keys from the napalm-logs object:', exc_info=True)
              log.warning(dict_object)
              continue  # jump to the next object in the queue
          log.debug('Sending event %s', tag)
          log.debug(raw_object)
          if master:
              event.get_master_event(__opts__,
                                     __opts__['sock_dir']
                                     ).fire_event(dict_object, tag)
          else:
              __salt__['event.send'](tag, dict_object)