UpdateInterval: features.StatusUpdateInterval,
			PodName:        args.PodName,
		}
		s.addStartFunc("status reporter init", func(stop <-chan struct{}) error {
			s.statusReporter.Init(s.environment.GetLedger(), stop)
			return nil
		})
		s.addTerminatingStartFunc("status reporter", func(stop <-chan struct{}) error {
			if writeStatus {
				s.statusReporter.Start(s.kubeClient.Kube(), args.Namespace, args.PodName, stop)

	return
}

func (e *Environment) ClusterLocal() ClusterLocalProvider {
	return e.clusterLocalServices
}

func (e *Environment) GetLedger() ledger.Ledger {
	return e.ledger
}

func (e *Environment) SetLedger(l ledger.Ledger) {
	e.ledger = l
}

	}

	ledger := ledger.Make(time.Minute)
	ledger.Put("key", "value") // If there is no config, ledger would be empty
	s.Env().SetLedger(ledger)
	reporter := &distribution.Reporter{
		UpdateInterval: features.StatusUpdateInterval,
	}
	reporter.Init(s.Env().GetLedger(), test.NewStop(t))
	s.Discovery.StatusReporter = reporter

	ads := s.ConnectADS().WithType(v3.ClusterType)
	// Subscribe to clusters

	if len(nonce) < VersionLen {
		return ""
	}
	configVersion := nonce[:VersionLen]
	result, ok := cache[configVersion]
	if !ok {
		lookupResult, err := s.Env.GetLedger().GetPreviousValue(configVersion, key)
		if err != nil {
			istiolog.Errorf("Unable to retrieve resource %s at version %s: %v", key, configVersion, err)
			lookupResult = ""
		}

func NewServer(args *PilotArgs, initFuncs ...func(*Server)) (*Server, error) {
	e := model.NewEnvironment()
	e.DomainSuffix = args.RegistryOptions.KubeOptions.DomainSuffix
	e.SetLedger(buildLedger(args.RegistryOptions))

	ac := aggregate.NewController(aggregate.Options{
		MeshHolder: e,
	})
	e.ServiceDiscovery = ac

	s := &Server{
		clusterID:               getClusterID(args),