text: """
  Display DNS resolution success on a configured domain.
  
  This module launch a simple query on each nameservers for the specified domain.
  Nameservers are dynamically retrieved. The FQDN is the only one mandatory
  parameter.  It's also possible to add additional nameservers by appending them
  in nameservers list.
  
  The default resolver can be overwritten with my_resolver.nameservers parameter.
  
  Configuration parameters:
      cache_timeout: how often we refresh this module in seconds (default 300)
      domain: domain name to check (default '')
      format: output format string (default '{total_count} NS {status}')
      lifetime: resolver lifetime (default 0.3)
      nameservers: specify a list of reference DNS nameservers (default [])
      resolvers: specify a list of DNS resolvers to use (default [])
  
  Format placeholders:
      {nok_count} The number of failed name servers
      {ok_count} The number of working name servers
      {status} The overall status of the name servers (OK or NOK)
      {total_count} The total number of name servers
  
  Color options:
      color_bad: One or more lookups have failed
      color_good: All lookups have succeeded
  
  Requires:
      dnspython: a dns toolkit for python
  
  @author nawadanp
  
  SAMPLE OUTPUT
  {'full_text': '10 NS OK'}
  """
  
  import dns.resolver
  import socket
  
  
  class Py3status:
      """
      """
  
      # available configuration parameters
      cache_timeout = 300
      domain = ""
      format = "{total_count} NS {status}"
      lifetime = 0.3
      nameservers = []
      resolvers = []
  
      def post_config_hook(self):
          # parse some configuration parameters
          if not isinstance(self.nameservers, list):
              self.nameservers = self.nameservers.split(",")
          if not isinstance(self.resolvers, list):
              self.resolvers = self.resolvers.split(",")
  
      def ns_checker(self):
          response = {
              "cached_until": self.py3.time_in(self.cache_timeout),
              "color": self.py3.COLOR_GOOD,
          }
          count_nok = 0
          count_ok = 0
          nameservers = []
          status = "OK"
  
          my_resolver = dns.resolver.Resolver()
          my_resolver.lifetime = self.lifetime
          if self.resolvers:
              my_resolver.nameservers = self.resolvers
  
          my_ns = my_resolver.query(self.domain, "NS")
  
          # Insert each NS ip address in nameservers
          for ns in my_ns:
              nameservers.append(str(socket.gethostbyname(str(ns))))
          for ns in self.nameservers:
              nameservers.append(str(ns))
  
          # Perform a simple DNS query, for each NS servers
          for ns in nameservers:
              my_resolver.nameservers = [ns]
              try:
                  my_resolver.query(self.domain, "A")
                  count_ok += 1
              except:  # noqa e722
                  count_nok += 1
                  status = "NOK"
                  response["color"] = self.py3.COLOR_BAD
  
          response["full_text"] = self.py3.safe_format(
              self.format,
              dict(
                  total_count=len(nameservers),
                  nok_count=count_nok,
                  ok_count=count_ok,
                  status=status,
              ),
          )
  
          return response
  
  
  if __name__ == "__main__":
      """
      Run module in test mode.
      """
      from py3status.module_test import module_test
  
      module_test(Py3status)
  