if node.Type != model.SidecarProxy {
		// DNS resolution is only for sidecars
		return nil
	}
	return dnsServer.BuildNameTable(dnsServer.Config{
		Node:                        node,
		Push:                        push,
		MulticlusterHeadlessEnabled: features.MulticlusterHeadlessEnabled,
	})

		valid.Netns,
	).Return(nil)

	dpServer := &meshDataplane{
		kubeClient: client.Kube(),
		netServer:  fs,
	}

	handlers := setupHandlers(ctx, client, dpServer, "istio-system")

	// We are not going to start the server, so the sockpath is irrelevant
	pluginServer := startCniPluginServer(ctx, "/tmp/test.sock", handlers, dpServer)

	// label the namespace

@Requires(UnitTestPreconditions.NotWindows)
class MavenPublishGcsIntegrationTest extends AbstractMavenPublishIntegTest {
    @Rule
    public GcsServer server = new GcsServer(temporaryFolder)

    def setup() {
        executer.withArgument('-i')
        executer.withArgument("-D${GCS_ENDPOINT_PROPERTY}=${server.uri}")
        executer.withArgument("-D${GCS_SERVICE_PATH_PROPERTY}=/")

    String mavenVersion = "1.45"
    String projectName = "publishGcsTest"
    String bucket = 'testGcsbucket'
    String repositoryPath = '/maven/release/'

    @Rule
    public final GcsServer server = new GcsServer(temporaryFolder)

    def setup() {
        executer.withArgument('-i')
        executer.withArgument("-D${GCS_ENDPOINT_PROPERTY}=${server.uri}")
        executer.withArgument("-D${GCS_SERVICE_PATH_PROPERTY}=/")

class IvyGcsModule extends DelegatingIvyModule<IvyGcsModule> implements RemoteIvyModule {
    IvyFileModule backingModule
    String bucket
    GcsServer server
    String repositoryPath

    IvyGcsModule(GcsServer server, IvyFileModule backingModule, String repositoryPath, String bucket) {
        super(backingModule)
        this.bucket = bucket
        this.server = server

import org.gradle.test.fixtures.ivy.RemoteIvyRepository

class IvyGcsRepository implements RemoteIvyRepository {

    GcsServer server
    String bucket
    IvyFileRepository backingRepository
    String repositoryPath

class MavenGcsModule extends DelegatingMavenModule<MavenGcsModule> implements RemoteMavenModule {
    MavenFileModule backingModule
    GcsServer server
    String bucket
    String repositoryPath

    MavenGcsModule(GcsServer server, MavenFileModule backingModule, String repositoryPath, String bucket) {
        super(backingModule)
        this.bucket = bucket
        this.server = server

import org.gradle.test.fixtures.resource.RemoteResource

class GcsDirectoryResource implements RemoteResource {

    private final GcsServer server
    private final TestFile directory
    private final String bucket
    private final String path

    GcsDirectoryResource(GcsServer server, String bucket, TestFile directory) {
        this.bucket = bucket
        this.directory = directory
        this.server = server

    final String bucketName = 'org.gradle.artifacts'

    @Rule
    final TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())

    @Rule
    final GcsServer server = new GcsServer(temporaryFolder)

    def "should perform put, get and list on an Gcs bucket"() {
        setup:
        def fileContents = 'This is only a test'
        File file = temporaryFolder.createFile(FILE_NAME)

import static org.gradle.internal.resource.transport.gcp.gcs.GcsConnectionProperties.GCS_SERVICE_PATH_PROPERTY

class IvyGcsRepoResolveIntegrationTest extends AbstractIvyRemoteRepoResolveIntegrationTest {

    @Rule
    GcsServer server = new GcsServer(temporaryFolder)

    @Override
    RepositoryServer getServer() {
        return server
    }

    protected ExecutionResult succeeds(String... tasks) {