Name

ApplicationModel\EndpointAnnotation.cs (1)

ExpressionResolverTests.cs (1)

ApplicationModel\EndpointAnnotation.cs (1)

367AllocatedEndpointSnapshot.SetException(new InvalidOperationException($"The endpoint `{Name}` is not allocated"));

ApplicationModel\EndpointReference.cs (3)

30.Select(a => a.Name) 232.SingleOrDefault(a => string.Equals(a.Name, EndpointName, StringComparisons.EndpointAnnotationName)); 268EndpointName = endpoint.Name;

ApplicationModel\EndpointUpdateContext.cs (1)

19public string Name => _endpointAnnotation.Name;

ApplicationModel\HostUrl.cs (1)

73return r.GetEndpoint(ep.Name, networkContext);

ApplicationModel\IComputeEnvironmentResource.cs (2)

64_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.") 80throw new InvalidOperationException($"Endpoint '{endpoint.Name}' must specify a port for scheme '{scheme}'.");

ApplicationModel\ResourceExtensions.cs (2)

794endpoints.FirstOrDefault(e => string.Equals(e.Name, endpointName, StringComparisons.EndpointAnnotationName)) : 818endpoints.FirstOrDefault(e => string.Equals(e.Name, endpointName, StringComparisons.EndpointAnnotationName)) :

Ats\CoreExports.cs (1)

204endpoint => includedEndpointNames.Contains(endpoint.Name));

Dcp\ContainerNetworkEndpointProvisioner.cs (5)

190StringComparers.EndpointAnnotationName.Equals(serviceWithResource.EndpointAnnotation.Name, endpoint.Name)); 193throw new InvalidDataException($"Host endpoint '{endpoint.Name}' on resource '{hostResource.Resource.Name}' should have an associated DCP Service resource already set up"); 210service.Annotate(CustomResource.EndpointNameAnnotation, endpoint.Name); 253endpoint.Name,

Dcp\DcpExecutor.cs (7)

679_logger.LogWarning("Encountered the same service-endpoint combination more than once for {EndpointName} on resource {ResourceName} when creating default endpoint services. This should never happen.", endpoint.Name, sp.ModelResource.Name); 709svc.Annotate(CustomResource.EndpointNameAnnotation, endpoint.Name); 847_logger.LogDebug("Using persisted public port {Port} for proxyless endpoint '{EndpointName}' on persistent resource '{ResourceName}'.", persistedPort, endpoint.Name, resource.Name); 852_logger.LogDebug("Allocated public port {Port} for proxyless endpoint '{EndpointName}' on resource '{ResourceName}'.", publicPort, endpoint.Name, resource.Name); 859_logger.LogWarning("Failed to persist public port {Port} for proxyless endpoint '{EndpointName}' on persistent resource '{ResourceName}'. Enable user secrets, set a fixed public port, or configure the endpoint to use a proxy to avoid recreating the persistent resource each run.", publicPort, endpoint.Name, resource.Name); 901_logger.LogDebug("Ignoring invalid persisted public port value '{Port}' for proxyless endpoint '{EndpointName}' on persistent resource '{ResourceName}'.", configuredPort, endpoint.Name, resource.Name); 909return $"Resources:{resource.Name}:{endpoint.Name}:port";

Dcp\DcpModelUtilities.cs (10)

39throw new InvalidOperationException($"The endpoint '{endpoint.Name}' for container resource '{modelResourceName}' must specify the {nameof(EndpointAnnotation.TargetPort)} value"); 44throw new InvalidOperationException($"The endpoint '{endpoint.Name}' for resource '{modelResourceName}' is not using a proxy, and it has a value of {nameof(EndpointAnnotation.Port)} property that is different from the value of {nameof(EndpointAnnotation.TargetPort)} property. For proxy-less endpoints they must match."); 71throw new InvalidOperationException($"Resource '{modelResourceName}' uses multiple replicas and a proxy-less endpoint '{ea.Name}'. These features do not work together."); 81$"The endpoint '{ea.Name}' for resource '{modelResourceName}' requested a proxy ({nameof(ea.IsProxied)} is true). Non-container resources cannot be proxied when both {nameof(ea.TargetPort)} and {nameof(ea.Port)} are specified with the same value."); 87$"Resource '{modelResourceName}' can have multiple replicas, and it uses endpoint '{ea.Name}' that has {nameof(ea.TargetPort)} property set. Each replica must have a unique port; setting {nameof(ea.TargetPort)} is not allowed."); 196throw new InvalidOperationException($"Service '{svc.Metadata.Name}' needs to specify a port for endpoint '{sp.EndpointAnnotation.Name}' since it isn't using a proxy."); 316string.Equals(swr.EndpointAnnotation.Name, endpoint.Name, StringComparisons.EndpointAnnotationName) 321throw new InvalidDataException($"The '{endpoint.Name}' on resource '{ts.ResourceName}' should have an associated DCP Service resource already set up"); 346endpoint = endpoints.FirstOrDefault(e => string.Equals(e.Name, endpointName, StringComparisons.EndpointAnnotationName));

Dcp\DcpNameGenerator.cs (2)

127: GetObjectNameForResource(resource, _options.Value, endpoint.Name); 191=> $"{resource.Name}|{endpoint.Name}|{targetNetworkId.Value}";

Devcontainers\DevcontainerPortForwardingEventingSubscriber.cs (1)

47$"{@event.Resource.Name}-{endpoint.Name}");

Orchestrator\ApplicationOrchestrator.cs (7)

324_logger.LogTrace("Setting primary launch profile endpoint to '{EndpointName}' for resource '{ResourceName}'.", endpoint.Name, resource.Name); 416_logger.LogTrace("Added URL '{Url}' for endpoint '{EndpointName}' on resource '{ResourceName}'.", url.Url, endpoint.Name, resource.Name); 423_logger.LogTrace("Added additional URL '{Url}' for endpoint '{EndpointName}' on resource '{ResourceName}'.", additionalUrl.Url, endpoint.Name, resource.Name); 481var primaryUrl = urls.FirstOrDefault(u => string.Equals(u.Endpoint?.EndpointName, primaryLaunchProfileEndpoint.Name, StringComparisons.EndpointAnnotationName)); 492_logger.LogTrace("Applying path '{Path}' from URL '{Url}' for primary launch profile endpoint '{EndpointName}' to other launch profile endpoints for resource '{ResourceName}'.", primaryPath, primaryUrl.Url, primaryLaunchProfileEndpoint.Name, resource.Name); 517_logger.LogTrace("URL '{Url}' for primary launch profile endpoint '{EndpointName}' for resource '{ResourceName}' does not have a path to apply to other launch profile endpoints.", primaryUrl.Url, primaryLaunchProfileEndpoint.Name, resource.Name); 525_logger.LogTrace("Could not find URL for primary launch profile endpoint '{EndpointName}' for resource '{ResourceName}'.", primaryLaunchProfileEndpoint.Name, resource.Name);

ProjectResourceBuilderExtensions.cs (3)

803var url = context.Urls.FirstOrDefault(u => string.Equals(u.Endpoint?.EndpointName, endpoint.Name, StringComparisons.EndpointAnnotationName)); 862projectResource.Annotations.OfType<EndpointAnnotation>().FirstOrDefault(sb => sb.UriScheme == scheme || string.Equals(sb.Name, scheme, StringComparisons.EndpointAnnotationName)); 1246context.EnvironmentVariables[$"Kestrel__Endpoints__{e.EndpointAnnotation.Name}__Url"] = url;

Publishing\ManifestPublishingContext.cs (1)

514Writer.WriteStartObject(endpoint.Name);

ResourceBuilderExtensions.cs (3)

1781.SingleOrDefault(ea => string.Equals(ea.Name, endpointName, StringComparisons.EndpointAnnotationName)); 1846!builder.Resource.Annotations.OfType<EndpointAnnotation>().Any(endpoint => string.Equals(endpoint.Name, endpointName, StringComparisons.EndpointAnnotationName))) 1884.FirstOrDefault(sb => string.Equals(sb.Name, resolvedName, StringComparisons.EndpointAnnotationName));

AzureContainerAppEnvironmentResource.cs (1)

412_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.")

ContainerAppContext.cs (4)

159throw new NotSupportedException($"The endpoint(s) {string.Join(", ", unsupportedEndpoints.Select(r => $"'{r.Endpoint.Name}'"))} specify an unsupported transport. The supported transports are 'http', 'http2', and 'tcp'."); 241_endpointMapping[endpoint.Name] = new(scheme, NormalizedContainerAppName, port, targetPort, true, httpIngress.External, 250.Select(r => r.Endpoint.Name) 274_endpointMapping[endpoint.Name] = new(endpoint.UriScheme, NormalizedContainerAppName, resolved.ExposedPort.Value ?? g.Port.Value, g.Port.Value, false, g.External, endpoint.TlsEnabled);

AzureAppServiceEnvironmentResource.cs (1)

539_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.")

AzureAppServiceWebsiteContext.cs (4)

141throw new NotSupportedException($"The endpoint(s) {string.Join(", ", unsupportedEndpoints.Select(r => $"'{r.Endpoint.Name}'"))} on resource '{resource.Name}' specifies an unsupported scheme. Only http and https are supported in App Service."); 164throw new NotSupportedException($"The endpoint '{endpoint.Name}' on resource '{resource.Name}' is not external. App Service only supports external endpoints."); 174_endpointMapping[endpoint.Name] = new( 188.Select(r => r.Endpoint.Name)

AddAzureKustoTests.cs (2)

70var httpEndpoint = endpointAnnotations.SingleOrDefault(e => e.Name == "http"); 360var httpEndpoint = endpointAnnotations.SingleOrDefault(e => e.Name == "http");

AzureSandboxContainerDeployment.cs (8)

1496$"Endpoint '{resolvedEndpoint.Endpoint.Name}' on project resource '{resource.TargetResource.Name}' is exposed through Azure sandbox ingress, which terminates TLS and forwards plaintext HTTP. " + 1504throw new InvalidOperationException($"Endpoint '{resolvedEndpoint.Endpoint.Name}' on resource '{resource.TargetResource.Name}' does not have a target port. Configure a target port before deploying it to an Azure sandbox."); 1509endpointOptions?.TryGetValue(resolvedEndpoint.Endpoint.Name, out resolvedEndpointOptions); 1510unmatchedEndpointOptions?.Remove(resolvedEndpoint.Endpoint.Name); 1512resolvedEndpoint.Endpoint.Name, 1523throw new NotSupportedException($"Endpoint '{resolvedEndpoint.Endpoint.Name}' on resource '{resource.TargetResource.Name}' shares target port {resolvedTargetPort} with endpoint '{existingEndpoint.Name}' but uses a different transport. Azure sandbox ports support a single HTTP protocol per target port."); 1530throw new NotSupportedException($"Endpoint '{resolvedEndpoint.Endpoint.Name}' on resource '{resource.TargetResource.Name}' shares target port {resolvedTargetPort} with endpoint '{existingEndpoint.Name}' but configures a different anonymous-access policy. Azure sandbox ports support a single access policy per target port."); 1580_ => throw new NotSupportedException($"Endpoint '{endpoint.Name}' on resource '{resource.Name}' uses transport '{endpoint.Transport}'. Azure sandbox ports currently support only HTTP and HTTP/2 endpoints.")

AzureSandboxEndpointPropertyValueProvider.cs (1)

188if (string.Equals(resolvedEndpoint.Endpoint.Name, endpointName, StringComparison.Ordinal))

AzureServiceBusExtensions.cs (1)

467if (!sqlServerBuilder.Resource.Annotations.OfType<EndpointAnnotation>().Any(e => e.Name == SqlServerEndpointName))

AzureCosmosDBExtensionsTests.cs (7)

809var emulatorEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "emulator"); 841var emulatorEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "emulator"); 870var dataExplorerEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "data-explorer"); 900var dataExplorerEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "data-explorer"); 1013var endpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "data-explorer"); 1073var healthEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "emulatorhealth"); 1124var endpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "data-explorer");

AzureEventHubsExtensionsTests.cs (2)

248Assert.Equal("emulator", endpoints[0].Name); 251Assert.Equal("emulatorhealth", endpoints[1].Name);

AzureFunctionsTests.cs (2)

469Assert.DoesNotContain(functionsResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "debug"); 496var endpoint = Assert.Single(funcApp.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "http");

AzureManagedRedisExtensionsTests.cs (1)

90Assert.Equal("tcp", endpoint.Name);

AzurePostgresExtensionsTests.cs (1)

185Assert.Equal("tcp", endpoint.Name);

AzureRedisExtensionsTests.cs (1)

134Assert.Equal("tcp", endpoint.Name);

AzureServiceBusExtensionsTests.cs (2)

808var endpoint = sql.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "tcp"); 985var endpoint = resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "tcp");

AzureSqlExtensionsTests.cs (1)

152Assert.Equal("tcp", endpoint.Name);

DurableTaskResourceExtensionsTests.cs (3)

169var grpc = endpointAnnotations.SingleOrDefault(e => e.Name == "grpc"); 173var http = endpointAnnotations.SingleOrDefault(e => e.Name == "http"); 178var dashboard = endpointAnnotations.SingleOrDefault(e => e.Name == "dashboard");

BlazorGatewayExtensions.cs (1)

881Name: ep.Name,

BrowserDebuggerHelper.cs (1)

115var endpointReference = parentResource.GetEndpoint(endpointAnnotation.Name);

AddBlazorGatewayTests.cs (4)

51gateway.Resource.Annotations.OfType<EndpointAnnotation>().OrderBy(endpoint => endpoint.Name), 52endpoint => Assert.Equal("http", endpoint.Name), 53endpoint => Assert.Equal("https", endpoint.Name)); 222gateway.Resource.Annotations.Remove(gateway.Resource.Annotations.OfType<EndpointAnnotation>().Single(endpoint => endpoint.Name == "https"));

AddDotnetProjectBlazorGatewayTests.cs (1)

29gateway.Resource.Annotations.OfType<EndpointAnnotation>().Select(e => e.Name));

BrowserLogsBuilderExtensions.cs (2)

333var endpointReference = resource.GetEndpoint(endpointAnnotation.Name); 336throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, BrowserMessageStrings.BrowserLogsEndpointNotAllocated, endpointAnnotation.Name, resource.Name));

src\Aspire.Hosting.Browsers\BrowserLogsBuilderExtensions.cs (2)

333var endpointReference = resource.GetEndpoint(endpointAnnotation.Name); 336throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, BrowserMessageStrings.BrowserLogsEndpointNotAllocated, endpointAnnotation.Name, resource.Name));

DevTunnelResourceBuilderExtensions.cs (2)

578.SingleOrDefault(a => string.Equals(a.Name, targetEndpoint.EndpointName, StringComparisons.EndpointAnnotationName)) is { } targetEndpointAnnotation) 584throw new ArgumentException($"Cannot tunnel endpoint '{targetEndpointAnnotation.Name}' with host '{targetEndpointAnnotation.TargetHost}' on resource '{targetResource.Name}' because it is not a localhost endpoint.", nameof(targetEndpoint));

DockerComposeEnvironmentContext.cs (2)

57serviceResource.EndpointMappings.Add(endpoint.Name, 64endpoint.Name));

DotnetProjectHostingExtensions.cs (1)

213endpoint => includedEndpointNames.Contains(endpoint.Name));

DotnetProjectOptionsTests.cs (1)

56Assert.Equal("http", endpoint.Name);

HostedAgent\AzureHostedAgentResource.cs (1)

495throw CreateEndpointResolutionException(hostedAgent, resource, environmentVariableName, endpointReference, $"Endpoint '{endpoint.Name}' is internal. Foundry hosted agents can only reference externally exposed endpoints during publish.");

HostedAgent\HostedAgentBuilderExtension.cs (2)

295var existingHttpEndpoint = builder.Resource.Annotations.OfType<EndpointAnnotation>().FirstOrDefault(e => e.Name == "http"); 570targetWithEndpoints.Annotations.OfType<EndpointAnnotation>().Any(e => string.Equals(e.Name, "http", StringComparisons.EndpointAnnotationName)))

HostedAgentExtensionTests.cs (4)

35Assert.Contains(endpoints, e => e.Name == "http"); 50var httpEndpoints = endpoints.Where(e => e.Name == "http").ToList(); 67var httpEndpoint = endpoints.Single(e => e.Name == "http"); 403Assert.Equal("http", endpoint.Name);

AddGarnetTests.cs (2)

30Assert.Equal("tcp", endpoint.Name); 58Assert.Equal("tcp", endpoint.Name);

AddQuarkusAppTests.cs (1)

145Assert.Equal("http", endpoint.Name);

AddSpringBootAppTests.cs (1)

157Assert.Equal("http", endpoint.Name);

DenoHostingExtensions.cs (2)

424.FirstOrDefault(e => string.Equals(e.Name, "http", StringComparison.OrdinalIgnoreCase)); 433.First(e => string.Equals(e.Name, "http", StringComparison.OrdinalIgnoreCase));

JavaScriptHostingExtensions.cs (1)

2965var endpointReference = parentResource.GetEndpoint(endpointAnnotation.Name);

AddDenoAppTests.cs (2)

1160Assert.Equal("http", endpoint.Name); 1189Assert.Equal("api", endpoint.Name);

AddKafkaTests.cs (4)

93var primaryEndpoint = Assert.Single(endpoints, e => e.Name == "tcp"); 96Assert.Equal("tcp", primaryEndpoint.Name); 102var internalEndpoint = Assert.Single(endpoints, e => e.Name == "internal"); 105Assert.Equal("internal", internalEndpoint.Name);

KeycloakResourceBuilderTests.cs (6)

34var endpoint = Assert.Single(containerResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == defaultEndpointName); 37Assert.Equal(defaultEndpointName, endpoint.Name); 45var healthEndpoint = Assert.Single(containerResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == managementEndpointName); 48Assert.Equal(managementEndpointName, healthEndpoint.Name); 85var primaryEndpoint = Assert.Single(endpoints, e => e.Name == "http"); 90Assert.DoesNotContain(endpoints, e => e.Name == "https");

KubernetesResource.cs (7)

254EndpointMappings[endpoint.Name] = new(endpoint.UriScheme, GetKubernetesProtocolName(endpoint.Protocol), resource.Name.ToServiceName(), httpMapping.Port, endpoint.Name); 274EndpointMappings[endpoint.Name] = new(endpoint.UriScheme, GetKubernetesProtocolName(endpoint.Protocol), resource.Name.ToServiceName(), HelmValue.Literal(portValue), endpoint.Name, ServicePort: servicePort); 283var paramName = $"port_{endpoint.Name}".ToHelmValuesSectionName(); 289EndpointMappings[endpoint.Name] = new(endpoint.UriScheme, GetKubernetesProtocolName(endpoint.Protocol), resource.Name.ToServiceName(), helmValue, endpoint.Name);

MauiPlatformExtensionsTests.cs (3)

773var dashboardEndpoint = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 825.Single(endpoint => endpoint.Name == KnownEndpointNames.OtlpHttpEndpointName); 828.Single(endpoint => endpoint.Name == KnownEndpointNames.OtlpGrpcEndpointName);

AddMilvusTests.cs (5)

36.FirstOrDefault(e => e.Name == "grpc"); 40Assert.Equal("grpc", endpoint.Name); 66.FirstOrDefault(e => e.Name == "grpc"); 70Assert.Equal("grpc", endpoint.Name); 197var grpcEndpoint = milvusResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "grpc");

AddMongoDBTests.cs (2)

53Assert.Equal("tcp", endpoint.Name); 81Assert.Equal("tcp", endpoint.Name);

AddMySqlTests.cs (2)

57Assert.Equal("tcp", endpoint.Name); 96Assert.Equal("tcp", endpoint.Name);

AddNatsTests.cs (2)

107Assert.Equal("tcp", endpoint.Name); 153Assert.Equal("tcp", endpoint.Name);

AddOracleTests.cs (3)

55Assert.Equal("tcp", endpoint.Name); 94Assert.Equal("tcp", endpoint.Name); 176Assert.Equal("tcp", endpoint.Name);

AddPostgresTests.cs (3)

66Assert.Equal("tcp", endpoint.Name); 120Assert.Equal("tcp", endpoint.Name); 236Assert.Equal("tcp", endpoint.Name);

PostgresMcpBuilderTests.cs (1)

33Assert.Equal(PostgresMcpContainerResource.PrimaryEndpointName, endpoint.Name);

AddQdrantTests.cs (8)

63.FirstOrDefault(e => e.Name == "grpc"); 67Assert.Equal("grpc", endpoint.Name); 102.FirstOrDefault(e => e.Name == "http"); 107Assert.Equal("http", endpoint.Name); 135.FirstOrDefault(e => e.Name == "grpc"); 139Assert.Equal("grpc", endpoint.Name); 424var grpcEndpoint = qdrantResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "grpc"); 432var httpEndpoint = qdrantResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "http");

AddRabbitMQTests.cs (4)

55var primaryEndpoint = Assert.Single(containerResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "tcp"); 58Assert.Equal("tcp", primaryEndpoint.Name); 66var mangementEndpoint = Assert.Single(containerResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "management"); 69Assert.Equal("management", mangementEndpoint.Name);

Publishing\RadiusInfrastructureBuilder.cs (5)

3501string.Equals(endpoints[0].Name, endpointReference.EndpointName, StringComparison.OrdinalIgnoreCase)) 3509$"address — that of its '{endpoints[0].Name}' endpoint. The reference to its '{endpointReference.EndpointName}' " + 3511$"for it would hand the consumer a wrong one. Reference the '{endpoints[0].Name}' endpoint, or deploy " + 3605if (RadiusServiceDiscovery.ResolveServicePort(resource, endpoint.Name) is not int containerPort) 3628ports[endpoint.Name] = port;

Publishing\RadiusServiceDiscovery.cs (1)

94.FirstOrDefault(r => string.Equals(r.Endpoint.Name, endpointName, StringComparison.OrdinalIgnoreCase));

RadiusEnvironmentResource.cs (3)

195var resolvedServicePort = new Lazy<int?>(() => RadiusServiceDiscovery.ResolveServicePort(endpointReference.Resource, endpoint.Name)); 217_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.") 322throw new InvalidOperationException($"Endpoint '{endpoint.Name}' must specify a port for scheme '{scheme}'.");

RedisBuilderExtensions.cs (1)

320var secondaryEndpoint = endpoints.FirstOrDefault(ep => string.Equals(ep.Name, RedisResource.SecondaryEndpointName, StringComparisons.EndpointAnnotationName));

AddRedisTests.cs (3)

47Assert.Equal("tcp", endpoint.Name); 75Assert.Equal("tcp", endpoint.Name); 953var endpoint = Assert.Single(redis.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "tcp");

AddSeqTests.cs (4)

29Assert.Equal("http", endpoint.Name); 57Assert.Equal("http", endpoint.Name); 183Assert.Equal("http", endpoint.Name); 216Assert.Equal("http", endpoint.Name);

AddSqlServerTests.cs (1)

55Assert.Equal("tcp", endpoint.Name);

Backchannel\AuxiliaryBackchannelRpcTargetTests.cs (1)

2165var endpoint = dashboard.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "http");

Dashboard\DashboardEventHandlersTests.cs (6)

484var endpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == expectedScheme); 486var otlpGrpcEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 488var otlpHttpEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpHttpEndpointName); 566var httpEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "http"); 568var otlpGrpcEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 570var otlpHttpEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpHttpEndpointName);

Dashboard\DashboardResourceTests.cs (14)

Dcp\DcpExecutorTests.cs (1)

3934.WithEndpointsInEnvironment(e => e.Name != "dontinjectme")

EndpointReferenceTests.cs (1)

352var expression = destination.GetEndpoint(annotation.Name).Property(property);

KestrelConfigTests.cs (10)

29Assert.Equal("http", a.Name); 35Assert.Equal("ExplicitHttp", a.Name); 65Assert.Equal("http", a.Name); 71Assert.Equal("ExplicitHttp", a.Name); 98Assert.Equal("https", a.Name); 115Assert.Equal("FirstHttpEndpoint", a.Name); 123Assert.Equal("SecondHttpEndpoint", a.Name); 284.WithEndpointsInEnvironment(e => e.Name != "FirstHttpEndpoint") 285.WithEndpointsInEnvironment(e => e.Name != "ExplicitProxiedHttp"); 457endpoint.AllocatedEndpoint = new AllocatedEndpoint(endpoint, "localhost", endpoint.Port ?? 0, targetPortExpression: $"port_{endpoint.Name}");

ProjectResourceTests.cs (3)

330Assert.Equal("https", a.Name); 336Assert.Equal("http", a.Name); 413.WithEndpointsInEnvironment(filter: e => e.Name != "dontinjectme")

PublishAsDockerfileTests.cs (5)

299Assert.Equal("http", endpoint.Name); 323Assert.Equal("http", endpoint.Name); 341var endpoints = container.Annotations.OfType<EndpointAnnotation>().OrderBy(e => e.Name).ToList(); 346Assert.Equal("http", e.Name); 351Assert.Equal("https", e.Name);

WithEndpointTests.cs (20)

WithOtlpExporterTests.cs (6)

174var annotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == endpointName); 204var grpcAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 207var httpAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpHttpEndpointName); 259var grpcAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 316var dashboardAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 319var collectorAnnotation = collector.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "otlp-grpc");

AddValkeyTests.cs (2)

30Assert.Equal("tcp", endpoint.Name); 58Assert.Equal("tcp", endpoint.Name);

AddYarpTests.cs (3)

30Assert.Equal("http", endpoint.Name); 446var httpsEndpoint = Assert.Single(yarp.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "https"); 471Assert.DoesNotContain(yarp.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "https");

TestProgram.cs (1)

193["Name"] = endpoint.Name,