code: func NewServer(cfg Config) (Server, error) {
  	if err := cfg.CheckAndSetDefaults(); err != nil {
  		return nil, trace.Wrap(err)
  	}
  	ctx, cancel := context.WithCancel(cfg.Context)
  	srv := &server{
  		Config:           cfg,
  		localSites:       []*localSite{},
  		remoteSites:      []*remoteSite{},
  		localAuthClient:  cfg.LocalAuthClient,
  		localAccessPoint: cfg.LocalAccessPoint,
  		newAccessPoint:   cfg.NewCachingAccessPoint,
  		limiter:          cfg.Limiter,
  		ctx:              ctx,
  		cancel:           cancel,
  		clusterPeers:     make(map[string]*clusterPeers),
  		Entry: log.WithFields(log.Fields{
  			trace.Component: cfg.Component,
  		}),
  	}
  
  	for _, clusterInfo := range cfg.DirectClusters {
  		cluster, err := newlocalSite(srv, clusterInfo.Name, clusterInfo.Client)
  		if err != nil {
  			return nil, trace.Wrap(err)
  		}
  
  		srv.localSites = append(srv.localSites, cluster)
  	}
  
  	var err error
  	s, err := sshutils.NewServer(
  		teleport.ComponentReverseTunnelServer,
  		// TODO(klizhentas): improve interface, use struct instead of parameter list
  		// this address is not used
  		utils.NetAddr{Addr: "127.0.0.1:1", AddrNetwork: "tcp"},
  		srv,
  		cfg.HostSigners,
  		sshutils.AuthMethods{
  			PublicKey: srv.keyAuth,
  		},
  		sshutils.SetLimiter(cfg.Limiter),
  		sshutils.SetCiphers(cfg.Ciphers),
  		sshutils.SetKEXAlgorithms(cfg.KEXAlgorithms),
  		sshutils.SetMACAlgorithms(cfg.MACAlgorithms),
  	)
  	if err != nil {
  		return nil, err
  	}
  	srv.srv = s
  	go srv.periodicFunctions()
  	return srv, nil
  }
docs: // NewServer creates and returns a reverse tunnel server which is fully
  // initialized but hasn't been started yet