}

// Simple Instance implementation, where fields are set individually.
type Simple struct {
	ProviderID provider.ID
	ClusterID  cluster.ID

	DiscoveryController
}

func (r Simple) Provider() provider.ID {
	return r.ProviderID
}

func (r Simple) Cluster() cluster.ID {
	return r.ClusterID

	})

	return nil
}

// initKubeRegistry creates all the k8s service controllers under this pilot
func (s *Server) initKubeRegistry(args *PilotArgs) (err error) {
	args.RegistryOptions.KubeOptions.ClusterID = s.clusterID
	args.RegistryOptions.KubeOptions.Revision = args.Revision
	args.RegistryOptions.KubeOptions.Metrics = s.environment
	args.RegistryOptions.KubeOptions.XDSUpdater = s.XDSServer

					s := xds.NewFakeDiscoveryServer(t, fakeOpts)
					for clusterID := range want {
						p := s.SetupProxy(&model.Proxy{Metadata: &model.NodeMetadata{ClusterID: clusterID}})
						eps := xdstest.ExtractLoadAssignments(s.Endpoints(p))[tt.serviceCluster]
						if want := want[clusterID]; !slices.EqualUnordered(eps, want) {
							t.Errorf("got %v but want %v for %s", eps, want, clusterID)
						}
					}
				})
			}
		})
	}

			}
			cds, lds, eds, rds, ecds := getSyncStatus(&clientConfig)
			cp := multixds.CpInfo(dr)
			fullStatus = append(fullStatus, &xdsWriterStatus{
				proxyID:               clientConfig.GetNode().GetId(),
				clusterID:             meta.ClusterID.String(),
				istiodID:              cp.ID,
				istiodVersion:         meta.IstioVersion,
				clusterStatus:         cds,
				listenerStatus:        lds,
				routeStatus:           rds,

			expectedException: true,
			expectedOutput:    "Error: expecting a WorkloadGroup artifact file or the name and namespace of an existing WorkloadGroup\n",
		},
		{
			description:       "Invalid command args - missing valid input spec",
			args:              strings.Split("entry configure -n bar -o temp --clusterID cid", " "),
			expectedException: true,

		XDSUpdater:            xdsUpdater,
		Metrics:               &model.Environment{},
		MeshNetworksWatcher:   opts.NetworksWatcher,
		MeshWatcher:           opts.MeshWatcher,
		ClusterID:             opts.ClusterID,
		MeshServiceController: meshServiceController,
		ConfigCluster:         opts.ConfigCluster,
		SystemNamespace:       opts.SystemNamespace,
	}
	c := NewController(opts.Client, options)

			cc := &Controller{
				nodes:       nodes,
				meshWatcher: mesh.NewFixedWatcher(mesh.DefaultMeshConfig()),
				networkManager: &networkManager{
					clusterID: c.ctl.cluster,
					network:   c.ctl.network,
				},
				opts: Options{ClusterID: c.ctl.cluster},
			}
			eb := cc.NewEndpointBuilder(&pod)

			assert.Equal(t, eb.labels, c.expected)
		})
	}
}

	c.ForEach(gvk.Service, func(r *resource.Instance) bool {
		clusterID := r.Origin.ClusterName()
		if clusterID == "" {
			return true
		}
		if _, ok := services[r.Metadata.FullName]; !ok {
			services[r.Metadata.FullName] = map[cluster.ID]*resource.Instance{}
		}
		services[r.Metadata.FullName][clusterID] = r
		return true
	})

	for fullname, clusterServices := range services {

			if !validateFlagIsSetManuallyOrNot(cmd, "clusterID") {
				// extract the cluster ID from the injector config if it is not set by user
				clusterName, err := extractClusterIDFromInjectionConfig(kubeClient, ctx.IstioNamespace())
				if err != nil {
					return fmt.Errorf("failed to automatically determine the --clusterID: %v", err)
				}
				if clusterName != "" {
					clusterID = clusterName
				}
			}

	"istio.io/istio/pilot/pkg/xds"
	v3 "istio.io/istio/pilot/pkg/xds/v3"
	"istio.io/istio/pkg/cluster"
)

func InitGenerators(
	s *xds.DiscoveryServer,
	cg core.ConfigGenerator,
	systemNameSpace string,
	clusterID cluster.ID,
	internalDebugMux *http.ServeMux,
) {
	env := s.Env
	generators := map[string]model.XdsResourceGenerator{}
	edsGen := &xds.EdsGenerator{Cache: s.Cache, EndpointIndex: env.EndpointIndex}