Name

ApplicationModel\EndpointAnnotation.cs (1)

ExpressionResolverTests.cs (1)

ApplicationModel\EndpointAnnotation.cs (1)

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

ApplicationModel\EndpointReference.cs (3)

31.Select(a => a.Name) 267.SingleOrDefault(a => string.Equals(a.Name, EndpointName, StringComparisons.EndpointAnnotationName)); 303EndpointName = endpoint.Name;

ApplicationModel\EndpointUpdateContext.cs (1)

19public string Name => _endpointAnnotation.Name;

ApplicationModel\HostUrl.cs (1)

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

ApplicationModel\IComputeEnvironmentResource.cs (3)

51$"Compute environment '{Name}' cannot provide browser origins for endpoint '{endpoint.Name}' on resource '{endpointReference.Resource.Name}' because it does not implement deployed browser-origin resolution. " + 71_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.") 87throw 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 (4)

673_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); 710svc.Annotate(CustomResource.EndpointNameAnnotation, endpoint.Name); 814_logger.LogDebug("Allocated public port {Port} for proxyless endpoint '{EndpointName}' on resource '{ResourceName}'.", publicPort, endpoint.Name, resource.Name); 825return new PersistentPortAllocationKey(resource.Name, endpoint.Name);

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."); 113throw new InvalidOperationException($"Resource '{modelResourceName}' uses multiple replicas and a proxy-less endpoint '{ea.Name}'. These features do not work together."); 123$"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."); 129$"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."); 238throw new InvalidOperationException($"Service '{svc.Metadata.Name}' needs to specify a port for endpoint '{sp.EndpointAnnotation.Name}' since it isn't using a proxy."); 358string.Equals(swr.EndpointAnnotation.Name, endpoint.Name, StringComparisons.EndpointAnnotationName) 363throw new InvalidDataException($"The '{endpoint.Name}' on resource '{ts.ResourceName}' should have an associated DCP Service resource already set up"); 388endpoint = 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}";

Dcp\PersistentPortAllocator.cs (1)

142var publicPortKey = new PersistentPortAllocationKey(resource.Name, endpoint.Name);

Devcontainers\DevcontainerPortForwardingEventingSubscriber.cs (1)

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

Orchestrator\ApplicationOrchestrator.cs (8)

340_logger.LogTrace("Setting primary launch profile endpoint to '{EndpointName}' for resource '{ResourceName}'.", endpoint.Name, resource.Name); 432_logger.LogTrace("Added URL '{Url}' for endpoint '{EndpointName}' on resource '{ResourceName}'.", url.Url, endpoint.Name, resource.Name); 439_logger.LogTrace("Added additional URL '{Url}' for endpoint '{EndpointName}' on resource '{ResourceName}'.", additionalUrl.Url, endpoint.Name, resource.Name); 500var primaryUrl = urls.FirstOrDefault(u => string.Equals(u.Endpoint?.EndpointName, primaryLaunchProfileEndpoint.Name, StringComparisons.EndpointAnnotationName)); 511_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); 536_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); 544_logger.LogTrace("Could not find URL for primary launch profile endpoint '{EndpointName}' for resource '{ResourceName}'.", primaryLaunchProfileEndpoint.Name, resource.Name); 595.Where(url => string.Equals(url.Annotation.Endpoint!.EndpointName, endpoint.Name, StringComparisons.EndpointAnnotationName))

ProjectResourceBuilderExtensions.cs (3)

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

Publishing\ManifestPublishingContext.cs (2)

565Writer.WriteStartObject(endpoint.Name); 1295endpoint.Endpoint.Resource.Name, endpoint.Endpoint.EndpointAnnotation.Name, endpoint.Property.ToString(),

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 (2)

440$"Azure Container Apps environment '{Name}' cannot provide browser origins for endpoint '{endpoint.Name}' on resource '{endpointReference.Resource.Name}' because it is not an external HTTP(S) endpoint. " + 461_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.")

ContainerAppContext.cs (4)

156throw 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'."); 238_endpointMapping[endpoint.Name] = new(scheme, NormalizedContainerAppName, port, targetPort, true, httpIngress.External, 247.Select(r => r.Endpoint.Name) 271_endpointMapping[endpoint.Name] = new(endpoint.UriScheme, NormalizedContainerAppName, resolved.ExposedPort.Value ?? g.Port.Value, g.Port.Value, false, g.External, endpoint.TlsEnabled);

AzureAppServiceEnvironmentResource.cs (2)

568$"Azure App Service environment '{Name}' cannot provide browser origins for endpoint '{endpoint.Name}' on resource '{endpointReference.Resource.Name}' because it is not an external HTTP(S) endpoint. " + 589_ => 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)

191if (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)

462Assert.DoesNotContain(functionsResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "debug"); 489var 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)

884Name: ep.Name,

BrowserDebuggerHelper.cs (1)

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

AddBlazorGatewayTests.cs (4)

76gateway.Resource.Annotations.OfType<EndpointAnnotation>().OrderBy(endpoint => endpoint.Name), 77endpoint => Assert.Equal("http", endpoint.Name), 78endpoint => Assert.Equal("https", endpoint.Name)); 249gateway.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));

src\Shared\EndpointPropertyInputCache.cs (1)

34reference.Endpoint.Resource.Name, reference.Endpoint.EndpointAnnotation.Name, reference.Property.ToString(), 64);

DotnetProjectHostingExtensions.cs (1)

271return builder.WithEndpointsInEnvironment(endpoint => includedEndpointNames.Contains(endpoint.Name));

DotnetProjectFacadeTests.cs (3)

23Assert.Same(resource, resource.WithEndpointsInEnvironment(endpoint => endpoint.Name == "http")); 119Assert.Same(resource, resource.WithEndpointsInEnvironment(endpoint => endpoint.Name != "admin")); 121resource.WithEndpointsInEnvironment(endpoint => endpoint.Name != "metrics");

DotnetProjectOptionsTests.cs (1)

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

HostedAgent\AzureHostedAgentResource.cs (1)

499throw 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)

38Assert.Contains(endpoints, e => e.Name == "http"); 53var httpEndpoints = endpoints.Where(e => e.Name == "http").ToList(); 70var httpEndpoint = endpoints.Single(e => e.Name == "http"); 406Assert.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)

2952var 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);

src\Shared\EndpointPropertyInputCache.cs (1)

34reference.Endpoint.Resource.Name, reference.Endpoint.EndpointAnnotation.Name, reference.Property.ToString(), 64);

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); 203var 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); 430var grpcEndpoint = qdrantResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "grpc"); 438var 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)

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

Publishing\RadiusServiceDiscovery.cs (1)

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

RadiusEnvironmentResource.cs (4)

195var resolvedServicePort = new Lazy<int?>(() => RadiusServiceDiscovery.ResolveServicePort(endpointReference.Resource, endpoint.Name)); 203$"Radius environment '{Name}' cannot provide browser origins for endpoint '{endpoint.Name}' on resource '{endpointReference.Resource.Name}' because its service DNS is cluster-local and does not establish a browser-facing address. " + 221_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.") 326throw new InvalidOperationException($"Endpoint '{endpoint.Name}' must specify a port for scheme '{scheme}'.");

src\Shared\EndpointPropertyInputCache.cs (1)

34reference.Endpoint.Resource.Name, reference.Endpoint.EndpointAnnotation.Name, reference.Property.ToString(), 64);

RedisBuilderExtensions.cs (1)

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

AddRedisTests.cs (3)

49Assert.Equal("tcp", endpoint.Name); 77Assert.Equal("tcp", endpoint.Name); 1015var 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)

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

Dashboard\DashboardEventHandlersTests.cs (6)

545var endpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == expectedScheme); 547var otlpGrpcEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 549var otlpHttpEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpHttpEndpointName); 627var httpEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "http"); 629var otlpGrpcEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 631var otlpHttpEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpHttpEndpointName);

Dashboard\DashboardResourceTests.cs (14)

Dcp\DcpExecutorTests.cs (1)

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

EndpointReferenceTests.cs (1)

388var 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"); 459endpoint.AllocatedEndpoint = new AllocatedEndpoint(endpoint, "localhost", endpoint.Port ?? 0, targetPortExpression: $"port_{endpoint.Name}");

ProjectResourceTests.cs (3)

358Assert.Equal("https", a.Name); 364Assert.Equal("http", a.Name); 441.WithEndpointsInEnvironment(filter: e => e.Name != "dontinjectme")

PublishAsDockerfileTests.cs (5)

305Assert.Equal("http", endpoint.Name); 331Assert.Equal("http", endpoint.Name); 351var endpoints = container.Annotations.OfType<EndpointAnnotation>().OrderBy(e => e.Name).ToList(); 356Assert.Equal("http", e.Name); 361Assert.Equal("https", e.Name);

WithEndpointTests.cs (20)

WithOtlpExporterTests.cs (6)

176var annotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == endpointName); 206var grpcAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 209var httpAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpHttpEndpointName); 261var grpcAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 318var dashboardAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 321var 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)

196["Name"] = endpoint.Name,