code: def wait_port_open(server, port, timeout=None):
      
      import socket
      import errno
      import time
      sleep_s = 0
      if timeout:
          from time import time as now
          # time module is needed to calc timeout shared between two exceptions
          end = now() + timeout
  
      while True:
          logging.debug("Sleeping for %s second(s)", sleep_s)
          time.sleep(sleep_s)
          s = socket.socket()
          try:
              if timeout:
                  next_timeout = end - now()
                  if next_timeout < 0:
                      return False
                  else:
                      s.settimeout(next_timeout)
  
              logging.info("connect %s %d", server, port)
              s.connect((server, port))
  
          except ConnectionError as err:
              logging.debug("ConnectionError %s", err)
              if sleep_s == 0:
                  sleep_s = 1
  
          except socket.gaierror as err:
              logging.debug("gaierror %s",err)
              return False
  
          except socket.timeout as err:
              # this exception occurs only if timeout is set
              if timeout:
                  return False
  
          except TimeoutError as err:
              # catch timeout exception from underlying network library
              # this one is different from socket.timeout
              raise
  
          else:
              s.close()
              logging.info("wait_port_open: port %s:%s is open", server, port)
              return True
docs: Wait for network service to appear
          @param server: host to connect to (str)
          @param port: port (int)
          @param timeout: in seconds, if None or 0 wait forever
          @return: True of False, if timeout is None may return only True or
                   throw unhandled network exception