code: func (s preparedGenericAPIServer) NonBlockingRun(stopCh <-chan struct{}) error {
  	// Use an stop channel to allow graceful shutdown without dropping audit events
  	// after http server shutdown.
  	auditStopCh := make(chan struct{})
  
  	// Start the audit backend before any request comes in. This means we must call Backend.Run
  	// before http server start serving. Otherwise the Backend.ProcessEvents call might block.
  	if s.AuditBackend != nil {
  		if err := s.AuditBackend.Run(auditStopCh); err != nil {
  			return fmt.Errorf("failed to run the audit backend: %v", err)
  		}
  	}
  
  	// Use an internal stop channel to allow cleanup of the listeners on error.
  	internalStopCh := make(chan struct{})
  	var stoppedCh <-chan struct{}
  	if s.SecureServingInfo != nil && s.Handler != nil {
  		var err error
  		stoppedCh, err = s.SecureServingInfo.Serve(s.Handler, s.ShutdownTimeout, internalStopCh)
  		if err != nil {
  			close(internalStopCh)
  			return err
  		}
  	}
  
  	// Now that listener have bound successfully, it is the
  	// responsibility of the caller to close the provided channel to
  	// ensure cleanup.
  	go func() {
  		<-stopCh
  		close(internalStopCh)
  		if stoppedCh != nil {
  			<-stoppedCh
  		}
  		s.HandlerChainWaitGroup.Wait()
  		close(auditStopCh)
  	}()
  
  	s.RunPostStartHooks(stopCh)
  
  	if _, err := systemd.SdNotify(true, "READY=1\n"); err != nil {
  		klog.Errorf("Unable to send systemd daemon successful start message: %v\n", err)
  	}
  
  	return nil
  }
docs: // NonBlockingRun spawns the secure http server. An error is
  // returned if the secure port cannot be listened on.