Name

AzureEventHubsEmulatorResource.cs (1)

24public override string Name => _innerResource.Name;

AzurePostgresResource.cs (1)

31public override string Name => _innerResource.Name;

AzureRedisResource.cs (1)

31public override string Name => _innerResource.Name;

AzureStorageEmulatorResource.cs (1)

17public override string Name => _innerResource.Name;

ApplicationModel\Resource.cs (1)

32Name = name;

ApplicationModel\CommandsConfigurationExtensions.cs (1)

192return new ExecuteCommandResult { Success = false, ErrorMessage = string.Format(CultureInfo.InvariantCulture, CommandStrings.RebuilderResourceNotFound, projectResource.Name) };

ApplicationModel\ContainerResource.cs (1)

40return $@"Type = {GetType().Name}, Name = ""{Name}"", Image = ""{imageName}""";

ApplicationModel\ParameterResource.cs (6)

75public string ValueExpression => $"{{{Name}.value}}"; 83get => _configurationKey ?? (IsConnectionString ? $"ConnectionStrings:{Name}" : $"Parameters:{Name}"); 141Name = Name, 143Label = Name, 146Placeholder = string.Format(CultureInfo.CurrentCulture, InteractionStrings.ParametersInputsParameterPlaceholder, Name)

ApplicationModel\ProjectResource.cs (2)

141var originalImageName = Name.ToLowerInvariant(); 300return $@"Type = {GetType().Name}, Name = ""{Name}"", Path = ""{path}""";

ApplicationModel\Resource.cs (1)

37return $@"Type = {GetType().Name}, Name = ""{Name}"", Annotations = {Annotations.Count}";

ConnectionStringBuilderExtensions.cs (1)

108evt.Logger.LogError(ex, "Failed to resolve connection string for resource '{ResourceName}'", r.Name);

ConnectionStringParameterResource.cs (1)

19string IManifestExpressionProvider.ValueExpression => $"{{{Name}.connectionString}}";

ContainerResourceBuilderExtensions.cs (3)

44Name = $"build-{builder.Resource.Name}", 64Name = $"push-{builder.Resource.Name}", 532throw new InvalidOperationException($"The resource '{builder.Resource.Name}' does not have a container image specified. Use WithImage to specify the container image and tag.");

Dcp\DcpExecutor.cs (6)

1393containerExec.Annotate(CustomResource.OtelServiceNameAnnotation, containerExecutable.Name); 1395containerExec.Annotate(CustomResource.ResourceNameAnnotation, containerExecutable.Name); 1418exe.Annotate(CustomResource.OtelServiceNameAnnotation, executable.Name); 1420exe.Annotate(CustomResource.ResourceNameAnnotation, executable.Name); 1463exe.Annotate(CustomResource.OtelServiceNameAnnotation, project.Name); 1465exe.Annotate(CustomResource.ResourceNameAnnotation, project.Name);

Exec\ExecResourceManager.cs (3)

202string execResourceName = project.Name + "-exec"; 223_logger.LogDebug("Exec resource '{ResourceName}' will wait until project '{Project}' starts up.", execResourceName, project.Name); 246string execResourceName = container.Name + "-exec";

ExecutableResourceBuilderExtensions.cs (4)

131if (builder.ApplicationBuilder.TryCreateResourceBuilder<ExecutableContainerResource>(builder.Resource.Name, out var existingBuilder)) 154cb.WithImage(builder.Resource.Name); 218throw new InvalidOperationException($"The resource '{builder.Resource.Name}' is missing the ExecutableAnnotation"); 222private sealed class ExecutableContainerResource(ExecutableResource er) : ContainerResource(er.Name)

ExternalServiceBuilderExtensions.cs (7)

122e.Logger.LogError(ex, "Failed to get value for URL parameter '{ParameterName}'", resource.UrlParameter?.Name); 134e.Logger.LogError("The value for URL parameter '{ParameterName}' is invalid: {Error}", resource.UrlParameter?.Name, message); 200throw new ArgumentException($"The URL for external service '{builder.Resource.Name}' is null.", nameof(builder)); 204throw new ArgumentException($"The URL '{builder.Resource.Uri}' for external service '{builder.Resource.Name}' cannot be used for HTTP health checks because it has a non-HTTP scheme.", nameof(builder)); 211var healthCheckKey = $"{builder.Resource.Name}_external{pathKey}_{statusCode}_check"; 286return HealthCheckResult.Unhealthy($"The URL '{urlValue}' from parameter '{_urlParameter.Name}' is invalid: {message}"); 292return HealthCheckResult.Unhealthy($"The URL '{uri}' from parameter '{_urlParameter.Name}' cannot be used for HTTP health checks because it has a non-HTTP scheme.");

Orchestrator\ParameterProcessor.cs (14)

ProjectResourceBuilderExtensions.cs (4)

840if (builder.ApplicationBuilder.TryCreateResourceBuilder<ProjectContainerResource>(builder.Resource.Name, out var existingBuilder)) 859cb.WithImage(builder.Resource.Name); 922var rebuilderName = $"{projectResource.Name}-rebuilder"; 1069private sealed class ProjectContainerResource(ProjectResource pr) : ContainerResource(pr.Name)

Publishing\ManifestPublishingContext.cs (3)

285Writer.WriteString("value", $"{{{parameter.Name}.inputs.value}}"); 382var resourceDockerfilePath = Path.Combine(manifestDirectory, $"{container.Name}.Dockerfile"); 783resourceName = CreateFormattedParameterResourceName(parameter.Name, format);

ResourceBuilderExtensions.cs (9)

src\Shared\LaunchProfiles\LaunchProfileExtensions.cs (1)

31return projectMetadata.GetLaunchSettings(projectResource.Name);

AzureBicepResource.cs (11)

160? Path.Combine(directory ?? Directory.CreateTempSubdirectory("aspire").FullName, $"{Name.ToLowerInvariant()}.module.bicep") 161: Path.Combine(TempDirectory, $"{Name.ToLowerInvariant()}.module.bicep"); 296context.Logger.LogDebug("Resource {ResourceName} is excluded from publish. Skipping provisioning.", resource.Name); 304context.Logger.LogDebug("Resource {ResourceName} is already provisioned. Skipping provisioning.", resource.Name); 321.CreateTaskAsync(new MarkdownString($"Deploying **{resource.Name}**"), context.CancellationToken) 333new MarkdownString($"Using existing deployment for **{resource.Name}**"), 344new MarkdownString($"Successfully provisioned **{resource.Name}**"), 359new MarkdownString($"Failed to provision **{resource.Name}**: {errorMessage}"), 620public string ValueExpression => $"{{{Resource.Name}.secretOutputs.{Name}}}"; 669throw new InvalidOperationException($"No output for {Name} on resource {Resource.Name}"); 679public string ValueExpression => $"{{{Resource.Name}.outputs.{Name}}}";

AzureEnvironmentResource.cs (2)

73Name = $"publish-{Name}", 74Description = $"Publishes the Azure environment configuration for {Name}.",

AzureProvisioningResource.cs (2)

81var infrastructure = new AzureResourceInfrastructure(this, Name); 96var moduleDestinationPath = Path.Combine(directory ?? generationPath, $"{Name}.module.bicep");

AzureProvisioningResourceExtensions.cs (1)

185parameterName ??= Infrastructure.NormalizeBicepIdentifier(parameterResource.Name);

AzurePublishingContext.cs (10)

156var moduleDirectory = outputDirectory.CreateSubdirectory(resource.Name); 158var modulePath = Path.Combine(moduleDirectory.FullName, $"{resource.Name}.bicep"); 162var identifier = Infrastructure.NormalizeBicepIdentifier(resource.Name); 164var module = new ModuleImport(identifier, $"{resource.Name}/{resource.Name}.bicep") 166Name = resource.Name 267$"Processing Azure resource {resource.Name}", 302$"Wrote bicep module for resource {resource.Name} to {module.Path}", 401var identifier = Infrastructure.NormalizeBicepIdentifier($"{output.Resource.Name}_{output.Name}"); 418var pid = Infrastructure.NormalizeBicepIdentifier(p.Name);

AzureResourcePreparer.cs (2)

304$"{resource.Name}-roles-{targetResource.Name}", 407$"{targetResource.Name}-roles",

AzureUserAssignedIdentityResource.cs (1)

52var identityName = Infrastructure.NormalizeBicepIdentifier(infrastructure.AspireResource.Name);

Provisioning\Provisioners\BicepProvisioner.cs (13)

35var section = configuration.GetSection($"Azure:Deployments:{resource.Name}"); 47logger.LogDebug("Checksum mismatch for resource {ResourceName}. Expected: {ExpectedChecksum}, Actual: {ActualChecksum}", resource.Name, currentCheckSum, configCheckSum); 51logger.LogDebug("Configuring resource {ResourceName} from existing deployment state.", resource.Name); 161logger.LogDebug("Setting parameters and scope for resource {ResourceName}", resource.Name); 180resourceLogger.LogInformation("Deploying {Name} to {ResourceGroup}", resource.Name, resourceGroup.Name); 181logger.LogDebug("Starting deployment of resource {ResourceName} to resource group {ResourceGroupName}", resource.Name, resourceGroup.Name); 187var deploymentName = executionContext.IsPublishMode ? $"{resource.Name}-{DateTimeOffset.Now.ToUnixTimeSeconds()}" : resource.Name; 198var url = GetDeploymentUrl(context, resourceGroup, resource.Name); 215resourceLogger.LogInformation("Deployment of {Name} to {ResourceGroup} took {Elapsed}", resource.Name, resourceGroup.Name, sw.Elapsed); 216logger.LogDebug("Deployment of resource {ResourceName} to resource group {ResourceGroupName} completed in {Elapsed}", resource.Name, resourceGroup.Name, sw.Elapsed); 231throw new InvalidOperationException($"Deployment of {resource.Name} to {resourceGroup.Name} failed with {deployment.Data.Properties.ProvisioningState}"); 238var sectionName = $"Azure:Deployments:{resource.Name}";

AzureAppConfigurationEmulatorResource.cs (1)

12public class AzureAppConfigurationEmulatorResource(AzureAppConfigurationResource innerResource) : ContainerResource(innerResource.Name), IResource

AzureAppConfigurationExtensions.cs (2)

60Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 135return builder.WithBindMount(path ?? $".aace/{builder.Resource.Name}", "/app/.aace", isReadOnly: false);

AzureContainerAppEnvironmentResource.cs (1)

230$"The container registry configured for the Azure Container App Environment '{Name}' is not an Azure Container Registry. " +

AzureContainerAppExtensions.cs (6)

89var identity = new UserAssignedIdentity(Infrastructure.NormalizeBicepIdentifier($"{appEnvResource.Name}_mi")) 109throw new InvalidOperationException($"No container registry associated with environment '{appEnvResource.Name}'. This should have been added automatically."); 128laWorkspace = new OperationalInsightsWorkspace(Infrastructure.NormalizeBicepIdentifier($"{appEnvResource.Name}_law")) 188storageVolume = new StorageAccount(Infrastructure.NormalizeBicepIdentifier($"{appEnvResource.Name}_storageVolume")) 329var sanitizedPrefix = new string(appEnvResource.Name.ToLowerInvariant() 518Tags = { { "aspire-resource-name", infra.AspireResource.Name } }

AzureContainerAppResource.cs (1)

61ctx.ReportingStep.Log(LogLevel.Information, new MarkdownString($"Successfully deployed **{targetResource.Name}** to Azure Container Apps environment **{containerAppEnv.Name}**. No public endpoints were configured."));

AzureAppServiceEnvironmentExtensions.cs (3)

54var prefix = infra.AspireResource.Name; 88throw new InvalidOperationException($"No container registry associated with environment '{resource.Name}'. This should have been added automatically."); 343Tags = { { "aspire-resource-name", infra.AspireResource.Name } }

AzureAppServiceEnvironmentResource.cs (1)

378$"The container registry configured for the Azure App Service Environment '{Name}' is not an Azure Container Registry. " +

AzureAppServiceEnvironmentUtility.cs (3)

32var prefix = infra.AspireResource.Name; 56Name = GetDashboardHostName(infra.AspireResource.Name), 98dashboard.SiteConfig.AppSettings.Add(new AppServiceNameValuePair { Name = "ASPIRE_ENVIRONMENT_NAME", Value = infra.AspireResource.Name });

AzureAppServiceWebsiteContext.cs (4)

586siteObj.SiteConfig.AppSettings.Add(new AppServiceNameValuePair { Name = "ASPIRE_ENVIRONMENT_NAME", Value = environmentContext.Environment.Name }); 590slot.SiteConfig.AppSettings.Add(new AppServiceNameValuePair { Name = "ASPIRE_ENVIRONMENT_NAME", Value = environmentContext.Environment.Name }); 820? Infrastructure.NormalizeBicepIdentifier($"{Infra.AspireResource.Name}_slot_ra") 821: Infrastructure.NormalizeBicepIdentifier($"{Infra.AspireResource.Name}_ra");

AzureOpenAIDeploymentResource.cs (1)

51/// This defaults to <see cref="Resource.Name"/>, but allows for a different deployment name in Azure.

AzureOpenAIExtensions.cs (2)

57CustomSubDomainName = ToLower(Take(Concat(infrastructure.AspireResource.Name, GetUniqueString(GetResourceGroup().Id)), 24)), 62Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureContainerRegistryExtensions.cs (1)

50Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureCosmosDBContainerResource.cs (1)

114Parent.Parent.GetChildConnectionString(Name, Parent.DatabaseName, ContainerName);

AzureCosmosDBDatabaseResource.cs (1)

40Parent.GetChildConnectionString(Name, DatabaseName, null);

AzureCosmosDBEmulatorResource.cs (1)

13: ContainerResource(innerResource.Name), IResource

AzureCosmosDBExtensions.cs (15)

109throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{builder.Resource.Name}' resource but the connection string was null."); 153var password = ParameterResourceBuilderExtensions.CreateDefaultPasswordParameter(builder.ApplicationBuilder, $"{builder.Resource.Name}-certificate-passphrase"); 190var healthCheckKey = $"{builder.Resource.Name}_check"; 480var kv = builder.ApplicationBuilder.AddAzureKeyVault($"{builder.Resource.Name}-kv") 512azureResource.ConnectionStringSecretOutput = keyVaultBuilder.Resource.GetSecret($"connectionstrings--{azureResource.Name}"); 513azureResource.PrimaryAccessKeySecretOutput = keyVaultBuilder.Resource.GetSecret($"primaryaccesskey--{azureResource.Name}"); 567Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 581var cosmosSqlDatabase = new CosmosDBSqlDatabase(Infrastructure.NormalizeBicepIdentifier(database.Name)) 594var cosmosContainer = new CosmosDBSqlContainer(Infrastructure.NormalizeBicepIdentifier(container.Name)) 629Name = $"connectionstrings--{azureResource.Name}", 640Name = $"primaryaccesskey--{azureResource.Name}", 650var dbSecret = new KeyVaultSecret(Infrastructure.NormalizeBicepIdentifier(database.Name + "_connectionString")) 653Name = AzureCosmosDBResource.GetKeyValueSecretName(database.Name), 663var containerSecret = new KeyVaultSecret(Infrastructure.NormalizeBicepIdentifier(container.Name + "_connectionString")) 666Name = AzureCosmosDBResource.GetKeyValueSecretName(container.Name),

AzureEventHubConsumerGroupResource.cs (2)

50var consumerGroup = new global::Azure.Provisioning.EventHubs.EventHubsConsumerGroup(Infrastructure.NormalizeBicepIdentifier(Name)); 63writer.WriteString(nameof(Name), ConsumerGroupName);

AzureEventHubResource.cs (2)

66var hub = new global::Azure.Provisioning.EventHubs.EventHub(Infrastructure.NormalizeBicepIdentifier(Name)); 86writer.WriteString(nameof(Name), hub.HubName);

AzureEventHubsEmulatorResource.cs (2)

13: ContainerResource(innerResource.Name), IResource 24public override string Name => _innerResource.Name;

AzureEventHubsExtensions.cs (2)

82Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 272.AddAzureStorage($"{builder.Resource.Name}-storage")

AzureFunctionsProjectResourceExtensions.cs (1)

141.FirstOrDefault(r => r.Name == storageResourceName);

src\Shared\LaunchProfiles\LaunchProfileExtensions.cs (1)

31return projectMetadata.GetLaunchSettings(projectResource.Name);

AzureKeyVaultResourceExtensions.cs (1)

97Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureKeyVaultSecretReference.cs (2)

30string IManifestExpressionProvider.ValueExpression => $"{{{azureKeyVaultResource.Name}.secrets.{SecretName}}}"; 39throw new InvalidOperationException($"Secret '{secretName}' not found in Key Vault '{azureKeyVaultResource.Name}'.");

AzureKustoBuilderExtensions.cs (11)

70Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 124throw new DistributedApplicationException($"ConnectionStringAvailableEvent published for resource '{db.Name}', but the connection string was null."); 129var healthCheckKey = $"{kustoDatabase.Name}_check"; 238throw new DistributedApplicationException($"ConnectionStringAvailableEvent published for resource '{resource.Name}', but the connection string was null."); 243var healthCheckKey = $"{resource.Name}_check"; 254throw new DistributedApplicationException($"Connection string for Kusto resource '{server.Name}' is not set."); 369throw new DistributedApplicationException($"Connection string for Kusto resource '{resourceBuilder.Resource.Name}' is not set."); 372var result = launcher.TryLaunchKustoExplorer(title: "", resourceBuilder.Resource.Name, connectionString, requestText: ""); 384throw new DistributedApplicationException($"Connection string for Kusto resource '{resourceBuilder.Resource.Name}' is not set."); 387var result = launcher.TryLaunchKustoWebExplorer(title: "", resourceBuilder.Resource.Name, connectionString, requestText: ""); 398message: $"Could not automatically open Kusto Web Explorer for resource '{resourceBuilder.Resource.Name}'. Click [{connectionString}]({connectionString}) to manually open the Web Explorer.",

AzureKustoClusterResource.cs (1)

127var kustoDb = KustoReadWriteDatabase.FromExisting(Infrastructure.NormalizeBicepIdentifier(db.Name));

AzureKustoEmulatorResource.cs (1)

18: base(innerResource?.Name ?? throw new ArgumentNullException(nameof(innerResource)))

AzureKustoReadWriteDatabaseResource.cs (1)

67var database = new KustoReadWriteDatabase(Infrastructure.NormalizeBicepIdentifier(Name));

AddAzureKustoTests.cs (1)

25Assert.Equal(name, resourceBuilder.Resource.Name);

KustoFunctionalTests.cs (7)

56await rns.WaitForResourceHealthyAsync(kusto.Resource.Name, cancellationToken: cts.Token); 109await rns.WaitForResourceHealthyAsync(kustoDb.Resource.Name, cancellationToken: cts.Token); 189await rns.WaitForResourceHealthyAsync(kusto.Resource.Name, cts.Token); 217await rns.WaitForResourceHealthyAsync(kusto.Resource.Name, cts.Token); 220await rns.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 221await rns.WaitForResourceAsync(db2.Resource.Name, KnownResourceStates.FailedToStart, cts.Token); 258await rns.WaitForResourceHealthyAsync(kustoDb.Resource.Name, cts.Token);

AzureNatGatewayExtensions.cs (2)

103Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 128Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureNetworkSecurityGroupExtensions.cs (2)

99$"A security rule named '{rule.Name}' already exists in Network Security Group '{builder.Resource.Name}'.", 122Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzurePrivateDnsZoneResource.cs (4)

84Tags = { { "aspire-resource-name", resource.Name } } 92var linkIdentifier = Infrastructure.NormalizeBicepIdentifier($"{vnetLink.VNet.Name}_link"); 96Name = $"{vnetLink.VNet.Name}-link", 101Tags = { { "aspire-resource-name", vnetLink.Name } }

AzurePrivateEndpointExtensions.cs (5)

58var name = $"{subnet.Resource.Name}-{target.Resource.Name}-pe"; 118Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 128Name = $"{azureResource.Name}-connection", 195var linkName = $"{dnsZone.Name}-{vnet.Name}-link";

AzurePublicIPAddressExtensions.cs (1)

71Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureSubnetResource.cs (2)

73public BicepOutputReference Id => new($"{Infrastructure.NormalizeBicepIdentifier(Name)}_Id", Parent); 98var subnet = new SubnetResource(Infrastructure.NormalizeBicepIdentifier(Name))

AzureVirtualNetworkExtensions.cs (3)

107Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 344$"The subnet '{builder.Resource.Name}' already has an NSG created via shorthand methods. " + 487var nsgName = $"{subnet.Name}-nsg";

AzurePostgresExtensions.cs (8)

228.ToDictionary(db => db.Name); 240azureResource.Name, 302var kv = builder.ApplicationBuilder.AddAzureKeyVault($"{builder.Resource.Name}-kv") 347ParameterResourceBuilderExtensions.CreateDefaultPasswordParameter(builder.ApplicationBuilder, $"{builder.Resource.Name}-password"); 350azureResource.ConnectionStringSecretOutput = keyVaultBuilder.Resource.GetSecret($"connectionstrings--{builder.Resource.Name}"); 443Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 534Name = $"connectionstrings--{azureResource.Name}", 609builder.ApplicationBuilder, $"{builder.Resource.Name}-username", secret: false, generatedUserName);

AzurePostgresFlexibleServerDatabaseResource.cs (1)

29public ReferenceExpression ConnectionStringExpression => Parent.GetDatabaseConnectionString(Name, databaseName);

AzurePostgresResource.cs (2)

15: AzureProvisioningResource(innerResource.Name, configureInfrastructure), IResourceWithConnectionString 31public override string Name => _innerResource.Name;

AzureManagedRedisExtensions.cs (6)

99var redisContainer = builder.ApplicationBuilder.AddRedis(azureResource.Name); 134var kv = builder.ApplicationBuilder.AddAzureKeyVault($"{builder.Resource.Name}-kv") 167azureResource.ConnectionStringSecretOutput = keyVaultBuilder.Resource.GetSecret($"connectionstrings--{azureResource.Name}"); 168azureResource.PrimaryAccessKeySecretOutput = keyVaultBuilder.Resource.GetSecret($"primaryaccesskey--{azureResource.Name}"); 252Name = $"connectionstrings--{redisResource.Name}", 263Name = $"primaryaccesskey--{redisResource.Name}",

AzureRedisExtensions.cs (5)

167var redisContainer = builder.ApplicationBuilder.AddRedis(azureResource.Name); 202var kv = builder.ApplicationBuilder.AddAzureKeyVault($"{builder.Resource.Name}-kv") 235azureResource.ConnectionStringSecretOutput = keyVaultBuilder.Resource.GetSecret($"connectionstrings--{azureResource.Name}"); 268Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 289Name = $"connectionstrings--{redisResource.Name}",

AzureRedisResource.cs (2)

15: AzureProvisioningResource(innerResource.Name, configureInfrastructure), IResourceWithConnectionString 31public override string Name => _innerResource.Name;

AzureServiceBusEmulatorResource.cs (1)

12public class AzureServiceBusEmulatorResource(AzureServiceBusResource innerResource) : ContainerResource(innerResource.Name), IResource

AzureServiceBusExtensions.cs (5)

80Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 301if (builder.Resource.Topics.FirstOrDefault(x => x.Name == topicName) is { } existingResource) 400var passwordParameter = ParameterResourceBuilderExtensions.CreateDefaultPasswordParameter(builder.ApplicationBuilder, $"{builder.Resource.Name}-sql-pwd", minLower: 1, minUpper: 1, minNumeric: 1); 414.AddContainer($"{builder.Resource.Name}-mssql", 585writer.WriteString("Name", emulatorResource.Name);

AzureServiceBusQueueResource.cs (2)

115var queue = new global::Azure.Provisioning.ServiceBus.ServiceBusQueue(Infrastructure.NormalizeBicepIdentifier(Name)); 166writer.WriteString(nameof(Name), queue.QueueName);

AzureServiceBusRule.cs (1)

121writer.WriteString(nameof(AzureServiceBusQueueResource.Name), rule.Name);

AzureServiceBusSubscriptionResource.cs (2)

109var subscription = new global::Azure.Provisioning.ServiceBus.ServiceBusSubscription(Infrastructure.NormalizeBicepIdentifier(Name)); 157writer.WriteString(nameof(Name), subscription.SubscriptionName);

AzureServiceBusTopicResource.cs (3)

85var topic = new global::Azure.Provisioning.ServiceBus.ServiceBusTopic(Infrastructure.NormalizeBicepIdentifier(Name)); 115if (topic.Name != null) 117writer.WriteString(nameof(Name), topic.TopicName);

AzureSignalREmulatorResource.cs (1)

12public class AzureSignalREmulatorResource(AzureSignalRResource innerResource) : ContainerResource(innerResource.Name), IResource

AzureSignalRExtensions.cs (1)

97Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } },

AzureSqlExtensions.cs (3)

189.ToDictionary(db => db.Name); 193var sqlContainer = builder.ApplicationBuilder.AddSqlServer(azureResource.Name); 319Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureSqlServerResource.cs (6)

53: base(innerResource.Name, configureInfrastructure) 186_databases.TryAdd(db.Name, db); 474var admin = builder.AddAzureUserAssignedIdentity($"{Name}-admin-identity") 478DeploymentScriptNetworkSecurityGroup = builder.AddNetworkSecurityGroup($"{Name}-nsg") 539var sqlName = azureSqlServer.Resource.Name; 630var aciSubnet = vnet.AddSubnet($"{sql.Name}-aci-subnet", aciSubnetCidr)

SubnetAddressAllocator.cs (3)

33$"Cannot automatically allocate a deployment script subnet for virtual network '{vnet.Name}' because it uses a parameterized address prefix. " + 42$"Virtual network '{vnet.Name}' address space '{vnetAddressPrefix}' is too small to allocate a /{prefixLength} subnet (requires at least {blockSize} addresses). " + 79$"Cannot allocate a /29 subnet in virtual network '{vnet.Name}' (address space: {vnetAddressPrefix}). " +

AzureBlobStorageContainerResource.cs (1)

44global::Azure.Provisioning.Storage.BlobContainer blobContainer = new(Infrastructure.NormalizeBicepIdentifier(Name))

AzureDataLakeStorageFileSystemResource.cs (1)

43BlobContainer blobContainer = new(Infrastructure.NormalizeBicepIdentifier(Name))

AzureQueueStorageQueueResource.cs (1)

44global::Azure.Provisioning.Storage.StorageQueue queue = new(Infrastructure.NormalizeBicepIdentifier(Name))

AzureStorageEmulatorResource.cs (2)

12public class AzureStorageEmulatorResource(AzureStorageResource innerResource) : ContainerResource(innerResource.Name), IResource 17public override string Name => _innerResource.Name;

AzureStorageExtensions.cs (15)

84Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 214var blobConnectionString = await builder.Resource.GetBlobConnectionString().GetValueAsync(ct).ConfigureAwait(false) ?? throw new DistributedApplicationException($"{nameof(ConnectionStringAvailableEvent)} was published for the '{builder.Resource.Name}' resource but the connection string was null."); 217var queueConnectionString = await builder.Resource.GetQueueConnectionString().GetValueAsync(ct).ConfigureAwait(false) ?? throw new DistributedApplicationException($"{nameof(ConnectionStringAvailableEvent)} was published for the '{builder.Resource.Name}' resource but the connection string was null."); 242var healthCheckKey = $"{builder.Resource.Name}_check"; 383if (string.Equals(name, builder.Resource.Name + "-blobs", StringComparisons.ResourceName)) 406if (string.Equals(name, builder.Resource.Name + "-data-lake", StringComparisons.ResourceName)) 443var name = builder.Resource.Name + "-blobs"; 452var name = builder.Resource.Name + "-data-lake"; 477var healthCheckKey = $"{resource.Name}_check"; 542var healthCheckKey = $"{resource.Name}_check"; 581if (string.Equals(name, builder.Resource.Name + "-queues", StringComparisons.ResourceName)) 600var name = builder.Resource.Name + "-queues"; 625var healthCheckKey = $"{resource.Name}_check"; 765var healthCheckKey = $"{resource.Name}_check"; 804var healthCheckKey = $"{resource.Name}_check";

AzureTableStorageResource.cs (1)

65global::Azure.Provisioning.Storage.TableService service = new(Infrastructure.NormalizeBicepIdentifier(Name));

AzureAppConfigurationExtensionsTests.cs (1)

66var appConfigRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "appConfig-roles");

AzureApplicationInsightsExtensionsTests.cs (3)

23Assert.Equal("appInsights", appInsights.Resource.Name); 44Assert.Equal("appInsights", appInsights.Resource.Name); 73Assert.Equal("appInsights", appInsights.Resource.Name);

AzureContainerAppsTests.cs (12)

AzureContainerRegistryTests.cs (1)

88var rolesResource = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "api-roles-acr");

AzureCosmosDBEmulatorFunctionalTests.cs (17)

47await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 49await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 53await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 55await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 93await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 97hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await cosmos.Resource.ConnectionStringExpression.GetValueAsync(default); 98hb.AddAzureCosmosClient(db.Resource.Name); 99hb.AddCosmosDbContext<EFCoreCosmosDbContext>(db.Resource.Name, databaseName); 174await rns.WaitForResourceHealthyAsync(cosmos1.Resource.Name, cts.Token); 182[$"ConnectionStrings:{cosmos1.Resource.Name}"] = await cosmos1.Resource.ConnectionStringExpression.GetValueAsync(default) 185hb.AddAzureCosmosClient(cosmos1.Resource.Name); 222await rns.WaitForResourceHealthyAsync(cosmos2.Resource.Name, cts.Token); 231[$"ConnectionStrings:{cosmos2.Resource.Name}"] = await cosmos2.Resource.ConnectionStringExpression.GetValueAsync(default) 234hb.AddAzureCosmosClient(cosmos2.Resource.Name); 292await rns.WaitForResourceHealthyAsync(cosmos.Resource.Name, cts.Token); 296hb.Configuration[$"ConnectionStrings:{cosmos.Resource.Name}"] = await cosmos.Resource.ConnectionStringExpression.GetValueAsync(default); 297hb.AddAzureCosmosClient(cosmos.Resource.Name);

AzureCosmosDBExtensionsTests.cs (6)

209var cosmosRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "cosmos-roles"); 335Assert.Equal(kvName, kv.Name); 365Assert.Equal("cosmos", cosmos.Resource.Name); 408Assert.Equal("cosmos", cosmos.Resource.Name); 469Assert.Equal("cosmos", cosmos.Resource.Name); 510Assert.Equal("cosmos", cosmos.Resource.Name);

AzureDeployerTests.cs (1)

634Name = p.Name,

AzureEnvironmentResourceExtensionsTests.cs (1)

72Assert.StartsWith("azure", resource.Name);

AzureEventHubsExtensionsTests.cs (7)

46await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 47await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 51await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 53await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 76await app.ResourceNotifications.WaitForResourceHealthyAsync(eventHubns.Resource.Name, cts.Token); 128await app.ResourceNotifications.WaitForResourceHealthyAsync(eventHubns.Resource.Name, cts.Token); 292var ehRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "eh-roles");

AzureFunctionsTests.cs (16)

153Assert.NotEqual(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, storageResources.Name); 154Assert.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, storageResources.Name); 172r => r.Name.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName)); 174Assert.Equal("my-own-storage", storageResource.Name); 198r => r.Name.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName)); 211Assert.NotEqual(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, resource.Name); 212Assert.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, resource.Name); 323var storage = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "funcstorage634f8"); 356var projRolesStorage = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "funcapp-roles-funcstorage634f8"); 384var projRolesStorage = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "funcapp-roles-my-own-storage"); 413var projRolesStorage = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "funcapp-roles-my-own-storage"); 444var projRolesStorage = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "funcapp-roles-my-own-storage"); 445var projRolesStorage2 = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "funcapp2-roles-funcstorage634f8"); 737.Where(r => r.Name.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName)) 763r => r.Name.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName)); 765Assert.Equal("my-custom-storage", storageResource.Name);

AzureKeyVaultTests.cs (2)

38var kvRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "mykv-roles"); 221Assert.Equal("mySecret", secretResource.Resource.Name);

AzureKustoExtensionsTests.cs (2)

30var kustoRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "kusto-roles"); 80Assert.Equal("myKusto", resource.Name);

AzureLogAnalyticsWorkspaceExtensionsTests.cs (1)

17Assert.Equal("logAnalyticsWorkspace", logAnalyticsWorkspace.Resource.Name);

AzureManagedRedisExtensionsTests.cs (1)

39var redisRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "redis-cache-roles");

AzureManifestUtils.cs (2)

58.OrderBy(r => r.Name) 67sb.AppendLine($"// Resource: {resource.Name}");

AzureNatGatewayExtensionsTests.cs (2)

20Assert.Equal("mynat", natGw.Resource.Name); 81Assert.Equal("mypip", pip.Resource.Name);

AzureNetworkSecurityGroupExtensionsTests.cs (1)

23Assert.Equal("web-nsg", nsg.Resource.Name);

AzureOpenAIExtensionsTests.cs (1)

81var openaiRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "openai-roles");

AzurePostgresExtensionsTests.cs (2)

43var postgresRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "postgres-data-roles"); 387Assert.Equal("db-mcp", mcpContainer.Name);

AzurePrivateEndpointExtensionsTests.cs (1)

25Assert.Equal("pesubnet-blobs-pe", pe.Resource.Name);

AzureRedisExtensionsTests.cs (1)

41var redisRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "redis-cache-roles");

AzureResourcePreparerTests.cs (4)

72var storageRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "storage-roles"); 116var storageRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "storage-roles"); 157Assert.DoesNotContain(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "dbsrv-roles"); 211var roleAssignmentResource = Assert.Single(model.Resources.OfType<AzureBicepResource>(), r => r.Name == "api-roles-storage");

AzureSearchExtensionsTests.cs (2)

35Assert.Equal("search", search.Resource.Name); 59var searchRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "search-roles");

AzureServiceBusExtensionsTests.cs (10)

96await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 98await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 102await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 104await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 137await rns.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token); 138await rns.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token); 722Assert.Equal("sb", serviceBus.Resource.Name); 741var sbRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "sb-roles"); 814await app.ResourceNotifications.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token); 815await app.ResourceNotifications.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token);

AzureSignalREmulatorFunctionalTest.cs (4)

60await app.ResourceNotifications.WaitForResourceAsync(signalR.Resource.Name, KnownResourceStates.Running, cts.Token); 61await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 65await app.ResourceNotifications.WaitForResourceHealthyAsync(signalR.Resource.Name, cts.Token); 67await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

AzureSignalRExtensionsTests.cs (2)

25var signalrRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "signalr-roles"); 47var signalrRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "signalr-roles");

AzureStorageEmulatorFunctionalTests.cs (17)

AzureStorageExtensionsTests.cs (7)

461Assert.Equal("storage", storage.Resource.Name); 546Assert.Equal("storage", storage.Resource.Name); 634Assert.Equal("storage", storage.Resource.Name); 653var storageRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "storage-roles"); 765Assert.Equal("storage", storage.Resource.Name); 852Assert.Equal("storage-blobs", blobService.Resource.Name); 879Assert.Equal("storage-queues", queueService.Resource.Name);

AzureUserAssignedIdentityTests.cs (12)

87var registryResource = Assert.Single(model.Resources.OfType<AzureContainerRegistryResource>(), r => r.Name == "myregistry"); 90var identityRoleAssignments = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "myidentity-roles-myregistry"); 119Assert.Equal("myidentity", identityResource.Name); 166Assert.Equal("myidentity", identityResource.Name); 175r => r.Name == "myapp-roles-mystorage"); 222Assert.Equal("myidentity", identityResource.Name); 231r => r.Name == "myapp-roles-mystorage"); 296r => Assert.True(r is AzureProvisioningResource { Name: "myapp-roles-mystorage" }), 297r => Assert.True(r is AzureProvisioningResource { Name: "myapp2-roles-mystorage" })); 301Assert.Equal("myidentity", identityResource.Name); 313r => r.Name == "myapp-roles-mystorage"); 315r => r.Name == "myapp2-roles-mystorage");

AzureVirtualNetworkExtensionsTests.cs (8)

22Assert.Equal("myvnet", vnet.Resource.Name); 34Assert.Equal("myvnet", vnet.Resource.Name); 48Assert.Equal("myvnet", vnet.Resource.Name); 76Assert.Equal("mysubnet", subnet.Resource.Name); 90Assert.Equal("mysubnet", subnet.Resource.Name); 172Assert.Equal("mysubnet", subnet.Resource.Name); 188Assert.Equal("mysubnet", subnet.Resource.Name); 233Assert.Equal("web-nsg", subnet.Resource.NetworkSecurityGroup.Name);

AzureWebPubSubExtensionsTests.cs (14)

35Assert.Equal(hubName, hub.Resource.Name); 63Assert.Equal("wps1", wps.Resource.Name); 108Assert.Equal("wps1", wps.Resource.Name); 138Assert.Equal("wps1", wps.Resource.Name); 164Assert.Equal("wps1", wps.Resource.Name); 218Assert.Equal("wps1", wps.Resource.Name); 234Assert.Equal("hub1", hub1.Resource.Name); 235Assert.Equal("resource2", hub2.Resource.Name); 236Assert.Equal("hub3", hub3.Resource.Name); 237Assert.Equal("hub4", hub4.Resource.Name); 262Assert.Equal("resource1", hub1.Resource.Name); 292Assert.Equal("wps1", wps.Resource.Name); 295var wpsRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "wps1-roles"); 348Assert.Equal("wps1", wps.Resource.Name);

ExistingAzureResourceExtensionsTests.cs (10)

38Assert.Equal("name", existingNameParameter.Name); 40Assert.Equal("resourceGroup", existingResourceGroupParameter.Name); 59Assert.Equal("name1", existingNameParameter.Name); 61Assert.Equal("resourceGroup1", existingResourceGroupParameter.Name); 77Assert.Equal("name", existingNameParameter.Name); 79Assert.Equal("resourceGroup", existingResourceGroupParameter.Name); 98Assert.Equal("name1", existingNameParameter.Name); 100Assert.Equal("resourceGroup1", existingResourceGroupParameter.Name); 136Assert.Equal("name", existingNameParameter.Name); 138Assert.Equal("resourceGroup", existingResourceGroupParameter.Name);

ExistingAzureResourceTests.cs (1)

80var messagingRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "messaging-roles");

FoundryExtensionsTests.cs (4)

21Assert.Equal("myAIFoundry", resource.Name); 33Assert.Equal("deployment1", deployment.Name); 93await rns.WaitForResourceAsync(resource.Name, [KnownResourceStates.FailedToStart, KnownResourceStates.Running], cts.Token); 176var roles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "foundry-roles");

RoleAssignmentTests.cs (6)

241var keyVaultResource = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "keyvault"); 270var keyVaultResource = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "keyvault"); 273var sbResource = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "sb"); 300var projRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "api-roles-keyvault"); 328Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == "server-roles-cache"); 351var projRoles = Assert.Single(model.Resources.OfType<AzureProvisioningResource>(), r => r.Name == $"api-roles-{azureResourceName}");

AzureWebPubSubExtensions.cs (2)

80Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 108var hub = new WebPubSubHub(Infrastructure.NormalizeBicepIdentifier(hubResource.Name))

tests\Aspire.Hosting.CodeGeneration.TypeScript.Tests\TestTypes\TestRedisResource.cs (1)

18ReferenceExpression.Create($"{Name}");

tests\Aspire.Hosting.CodeGeneration.TypeScript.Tests\TestTypes\TestRedisResource.cs (1)

18ReferenceExpression.Create($"{Name}");

tests\Aspire.Hosting.CodeGeneration.TypeScript.Tests\TestTypes\TestRedisResource.cs (1)

18ReferenceExpression.Create($"{Name}");

tests\Aspire.Hosting.CodeGeneration.TypeScript.Tests\TestTypes\TestRedisResource.cs (1)

18ReferenceExpression.Create($"{Name}");

TestTypes\TestRedisResource.cs (1)

18ReferenceExpression.Create($"{Name}");

DevTunnelResourceBuilderExtensions.cs (4)

446ErrorMessage = $"The dev tunnel '{tunnelResource.Name}' has not been associated with '{endpointName}' on resource '{targetResource.Name}'. Use 'WithReference({targetResource.Name})' on the dev tunnel to expose this endpoint." 540throw new ArgumentException($"Target endpoint '{targetEndpoint.EndpointName}' on resource '{targetEndpoint.Resource.Name}' has already been added to dev tunnel '{tunnel.Name}'.", nameof(targetEndpoint)); 566var portName = $"{tunnel.Name}-{targetResource.Name}-{targetEndpoint.EndpointName}"; 768await eventing.PublishAsync<ResourceStoppedEvent>(new(portResource, e.Services, new(portResource, portResource.Name, stoppedSnapshot!)), ct).ConfigureAwait(false);

DockerComposeEnvironmentContext.cs (3)

92var envVarName = $"{serviceResource.Name.ToUpperInvariant().Replace("-", "_").Replace(".", "_")}_BINDMOUNT_{bindMountIndex}"; 99description: $"Bind mount source for {serviceResource.Name}:{mount.Target}", 105logger.BindMountHostSpecificPath(serviceResource.Name, mount.Source, envVarName);

DockerComposeEnvironmentResource.cs (15)

67Name = $"publish-{Name}", 68Description = $"Publishes the Docker Compose environment configuration for {Name}.", 107Name = $"prepare-{Name}", 108Description = $"Prepares the Docker Compose environment {Name} for deployment.", 117Name = $"docker-compose-up-{Name}", 120DependsOnSteps = [$"prepare-{Name}"] 127Name = $"docker-compose-down-{Name}", 175.RequiredBy($"docker-compose-up-{Name}") 228new MarkdownString($"Running docker compose up for **{Name}**"), 270new MarkdownString($"Service **{Name}** is now running with Docker Compose locally"), 295new MarkdownString($"Running docker compose down for **{Name}**"), 329new MarkdownString($"Docker Compose shutdown complete for **{Name}**"), 394var environmentName = hostEnvironment?.EnvironmentName ?? environment.Name; 426return $"aspire-{environment.Name.ToLowerInvariant()}-{appHostSha[..8].ToLowerInvariant()}"; 430return $"aspire-{environment.Name.ToLowerInvariant()}";

DockerComposeServiceExtensions.cs (2)

99var env = parameter.Name.ToUpperInvariant().Replace("-", "_"); 105description: $"Parameter {parameter.Name}",

DockerComposeServiceResource.cs (2)

335new MarkdownString($"Successfully deployed **{TargetResource.Name}** to Docker Compose environment **{environment.Name}**. No public endpoints were configured.")); 356new MarkdownString($"Successfully deployed **{TargetResource.Name}** to Docker Compose environment **{environment.Name}**."));

DockerComposePublisherTests.cs (1)

300context.EnvironmentVariables[param.Name] = param;

AddDotnetToolTests.cs (1)

20Assert.Equal("mytool", tool.Resource.Name);

DotnetToolFunctionalTests.cs.cs (6)

23await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 24var terminalState = await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.TerminalStates, cts.Token); 28Assert.True(app.ResourceNotifications.TryGetCurrentState(resource.Resource.Name, out var resourceState)); 46await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 47var terminalState = await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.TerminalStates, cts.Token); 50Assert.True(app.ResourceNotifications.TryGetCurrentState(resource.Resource.Name, out var resourceState));

FoundryExtensions.cs (6)

157var healthCheckKey = $"{resource.Name}_check"; 381var healthCheckKey = $"{deployment.Name}_check"; 417CustomSubDomainName = ToLower(Take(Concat(infrastructure.AspireResource.Name, GetUniqueString(GetResourceGroup().Id)), 24)), 426Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 454var capHost = new CognitiveServicesCapabilityHost(Infrastructure.NormalizeBicepIdentifier($"{resource.Name}-caphost"), "2025-10-01-preview") 472var cdkDeployment = new CognitiveServicesAccountDeployment(Infrastructure.NormalizeBicepIdentifier(deployment.Name))

HostedAgent\AzureHostedAgentResource.cs (5)

40Name = $"deploy-{Name}", 45ctx.ReportingStep.Log(LogLevel.Information, $"Successfully deployed **{Name}** as Hosted Agent (version {version})", enableMarkdown: true); 101throw new InvalidOperationException($"Container image for hosted agent '{Name}' could not be resolved."); 140throw new InvalidOperationException($"Project '{project.Name}' does not have a valid connection string."); 145Name,

HostedAgent\AzurePromptAgentResource.cs (6)

35var deploymentAnnotation = this.GetDeploymentTargetAnnotation() ?? throw new InvalidOperationException($"Deployment target annotation is required on resource '{this.Name}' to deploy as hosted agent."); 37?? throw new InvalidOperationException($"Compute environment for resource '{this.Name}' must be an AzureCognitiveServicesProjectResource to deploy as hosted agent."); 41Name = $"deploy-{Name}", 46ctx.ReportingStep.Log(LogLevel.Information, $"Successfully deployed **{Name}** as Prompt Agent (version {version})", enableMarkdown: true); 117throw new InvalidOperationException($"Project '{project.Name}' does not have a valid connection string."); 132Name,

HostedAgent\HostedAgentBuilderExtension.cs (6)

254.AddFoundry($"{resource.Name}-proj-foundry") 255.AddProject($"{resource.Name}-proj"); 264var agentName = $"{resource.Name}-ha"; 280else if (builder.ApplicationBuilder.TryCreateResourceBuilder<ContainerResource>(resource.Name, out var crb)) 288if (builder.ApplicationBuilder.TryCreateResourceBuilder(resource.Name, out crb)) 294throw new InvalidOperationException($"Unable to create hosted agent for resource '{resource.Name}' because it could not be converted to a container resource.");

Project\AzureCognitiveServicesBase.cs (1)

114var r = AzureProvisionableAspireResource<P>.GetProvisionableResource(infra, builder.Resource.GetBicepIdentifier()) ?? throw new InvalidOperationException($"Provisionable resource for Aspire resource '{builder.Resource.Name}' not found in infrastructure.");

Project\ConnectionBuilderExtensions.cs (1)

220return builder.AddConnection($"{keyVault.Resource.Name}-{Guid.NewGuid():N}", (infra) =>

Project\ProjectBuilderExtension.cs (10)

122throw new InvalidOperationException($"Azure Cognitive Services project resource '{builder.Resource.Name}' already has a Key Vault connection configured."); 213var prefix = infra.AspireResource.Name; 270Name = aspireResource.Name, 274DisplayName = aspireResource.Name 276Tags = { { "aspire-resource-name", infra.AspireResource.Name } } 312throw new InvalidOperationException($"No container registry configured for Azure Cognitive Services project resource '{aspireResource.Name}'. A container registry is required to publish and run hosted agents."); 356Name = $"{aspireResource.Name}-ai", 374Name = $"{aspireResource.Name}-ai-conn", 406aspireResource.CapabilityHostConfiguration.Validate(aspireResource.Name); 592Tags = { { "aspire-resource-name", infra.AspireResource.Name } }

Project\ProjectResource.cs (3)

61$"https://ai.azure.com/nextgen/r/{encodedSubscriptionId},{resourceGroupName},,{Parent.Name},{Name}/home").ConfigureAwait(false); 149$"The container registry configured for the Azure Cognitive Services project '{Name}' is not an Azure Container Registry. " +

AddFoundryTests.cs (1)

20Assert.Equal(name, resourceBuilder.Resource.Name);

AddProjectTests.cs (1)

22Assert.Equal(name, resourceBuilder.Resource.Name);

HostedAgentExtensionTests.cs (1)

110Assert.Equal("agent-ha", hostedAgent.Name);

ProjectResourceTests.cs (3)

20Assert.Equal("my-project", project.Resource.Name); 127Assert.Equal("chat", deployment.Resource.Name); 142Assert.Equal("chat", deployment.Resource.Name);

GarnetBuilderExtensions.cs (1)

122throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{garnet.Name}' resource but the connection string was null.");

AddGarnetTests.cs (2)

25Assert.Equal("myGarnet", containerResource.Name); 53Assert.Equal("myGarnet", containerResource.Name);

GarnetFunctionalTests.cs (8)

40await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 42await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 46await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 48await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 75hb.Configuration[$"ConnectionStrings:{garnet.Resource.Name}"] = await garnet.Resource.ConnectionStringExpression.GetValueAsync(default); 77hb.AddRedisClient(garnet.Resource.Name); 155hb.Configuration[$"ConnectionStrings:{garnet1.Resource.Name}"] = $"{await garnet1.Resource.ConnectionStringExpression.GetValueAsync(default)}"; 207hb.Configuration[$"ConnectionStrings:{garnet2.Resource.Name}"] = $"{await garnet2.Resource.ConnectionStringExpression.GetValueAsync(default)}";

GitHubModelsExtensions.cs (1)

193var healthCheckKey = $"{builder.Resource.Name}_check";

GitHubModelsExtensionTests.cs (6)

20Assert.Equal("github", github.Resource.Name); 33Assert.Equal("mymodel-gh-apikey", github.Resource.Key.Name); 92Assert.Equal("github-gh-apikey", github.Resource.Key.Name); 119Assert.Equal("github-org", github.Resource.Organization.Name); 190Assert.Equal("test", resource.Name); 206Assert.Equal("test", resource.Name);

GitHubModelsFunctionalTests.cs (4)

41await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 43await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 47await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 49await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

JavaScriptHostingExtensions.cs (4)

628resourceLogger.LogWarning(ex, "Failed to generate Aspire Vite HTTPS config wrapper for resource '{ResourceName}'. Falling back to existing Vite config without Aspire modifications. Automatic HTTPS configuration won't be available", resource.Name); 1043var debuggerResourceName = $"{parentResource.Name}-browser"; 1065$"Resource '{parentResource.Name}' does not have an HTTP or HTTPS endpoint. Browser debugging requires an endpoint to navigate to."); 1116var installerName = $"{resource.Resource.Name}-installer";

AddNodeAppTests.cs (1)

485Assert.Equal("viteapp-browser", browserDebuggerResource.Name);

IntegrationTests.cs (1)

37Assert.Equal("vite-app-installer", npmInstallers[0].Name);

NodeAppFixture.cs (1)

109using var client = App.CreateHttpClient(NodeAppBuilder!.Resource.Name, endpointName: "http");

NodeFunctionalTests.cs (2)

25using var nodeClient = _nodeJsFixture.App.CreateHttpClient(_nodeJsFixture.NodeAppBuilder!.Resource.Name, "http"); 37using var npmClient = _nodeJsFixture.App.CreateHttpClient(_nodeJsFixture.NpmAppBuilder!.Resource.Name, "http");

PackageInstallationTests.cs (11)

ResourceCreationTests.cs (3)

107Assert.Equal("test-app-installer", installerResource.Name); 184Assert.Equal("test-app-installer", installerResource.Name); 207Assert.Equal("test-app-installer", installerResource.Name);

KafkaBuilderExtensions.cs (2)

48throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{kafka.Name}' resource but the connection string was null."); 222? ReferenceExpression.Create($"PLAINTEXT://localhost:29092,PLAINTEXT_HOST://localhost:{primaryEndpoint.Property(EndpointProperty.Port)},PLAINTEXT_INTERNAL://{resource.Name}:{internalEndpoint.Property(EndpointProperty.TargetPort)}")

AddKafkaTests.cs (1)

27Assert.Equal("kafka", containerResource.Name);

KafkaFunctionalTests.cs (7)

42await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 44await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 48await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 50await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 75hb.Configuration[$"ConnectionStrings:{kafka.Resource.Name}"] = await kafka.Resource.ConnectionStringExpression.GetValueAsync(default); 171hb.Configuration[$"ConnectionStrings:{kafka1.Resource.Name}"] = await kafka1.Resource.ConnectionStringExpression.GetValueAsync(default); 221hb.Configuration[$"ConnectionStrings:{kafka2.Resource.Name}"] = await kafka2.Resource.ConnectionStringExpression.GetValueAsync(default);

KeycloakResourceBuilderTests.cs (1)

26Assert.Equal(resourceName, containerResource.Name);

KubernetesEnvironmentResource.cs (2)

100Name = $"publish-{Name}", 101Description = $"Publishes the Kubernetes environment configuration for {Name}.",

KubernetesResource.cs (3)

492var formattedName = conditionParam.Name.ToHelmValuesSectionName(); 528var key = branchParam.Name.ToHelmValuesSectionName(); 592var formattedName = parameter.Name.ToHelmValuesSectionName();

MauiAndroidExtensions.cs (2)

54var name = $"{builder.Resource.Name}-android-device"; 245var name = $"{builder.Resource.Name}-android-emulator";

MauiiOSExtensions.cs (2)

58var name = $"{builder.Resource.Name}-ios-device"; 263var name = $"{builder.Resource.Name}-ios-simulator";

MauiMacCatalystExtensions.cs (1)

47var name = $"{builder.Resource.Name}-maccatalyst";

MauiOtlpExtensions.cs (1)

95var tunnelName = parentBuilder.Resource.Name;

MauiPlatformHelper.cs (1)

151context.EnvironmentVariables[KnownOtelConfigNames.ServiceName] = resource.Name;

MauiWindowsExtensions.cs (1)

47var name = $"{builder.Resource.Name}-windows";

MauiPlatformExtensionsTests.cs (9)

312Assert.NotEqual(androidDevice.Resource.Name, androidEmulator.Resource.Name); 339Assert.Equal("my-device", device.Resource.Name); 365Assert.Equal("my-emulator", emulator.Resource.Name); 391Assert.Equal("my-device", device.Resource.Name); 417Assert.Equal("my-simulator", simulator.Resource.Name); 445Assert.NotEqual(device.Resource.Name, simulator.Resource.Name); 654var stubName = tunnelConfig.OtlpStub.Name;

MilvusBuilderExtensions.cs (2)

138containerName ??= $"{builder.Resource.Name}-attu"; 224context.EnvironmentVariables["MILVUS_URL"] = $"{resource.PrimaryEndpoint.Scheme}://{resource.Name}:{resource.PrimaryEndpoint.TargetPort}";

AddMilvusTests.cs (1)

191Assert.Equal("my-milvus", milvusResource.Name);

MilvusFunctionalTests.cs (9)

30await app.WaitForTextAsync("Milvus Proxy successfully initialized and ready to serve", milvus.Resource.Name); 35hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 37hb.AddMilvusClient(db.Resource.Name); 107await app.WaitForTextAsync("Milvus Proxy successfully initialized and ready to serve", milvus1.Resource.Name); 114hb.Configuration[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default); 116hb.AddMilvusClient(db1.Resource.Name); 155await app.WaitForTextAsync("Milvus Proxy successfully initialized and ready to serve", milvus2.Resource.Name); 162hb.Configuration[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default); 164hb.AddMilvusClient(db2.Resource.Name);

MongoDBBuilderExtensions.cs (4)

71throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{mongoDBContainer.Name}' resource but the connection string was null."); 123throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{mongoDBDatabase.Name}' resource but the connection string was null."); 158containerName ??= $"{builder.Resource.Name}-mongoexpress"; 263context.EnvironmentVariables["ME_CONFIG_MONGODB_SERVER"] = resource.Name;

AddMongoDBTests.cs (2)

42Assert.Equal("mongodb", containerResource.Name); 70Assert.Equal("mongodb", containerResource.Name);

MongoDbFunctionalTests.cs (14)

52await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 54await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 58await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 60await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 86hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 88hb.AddMongoDBClient(db.Resource.Name); 151hb.Configuration[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default); 153hb.AddMongoDBClient(db1.Resource.Name); 196hb.Configuration[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default); 198hb.AddMongoDBClient(db2.Resource.Name); 308hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 310hb.AddMongoDBClient(db.Resource.Name); 399hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 401hb.AddMongoDBClient(db.Resource.Name);

MySqlBuilderExtensions.cs (5)

52throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{resource.Name}' resource but the connection string was null."); 60throw new DistributedApplicationException($"ResourceReadyEvent was published for the '{resource.Name}' resource but the connection string was null."); 68throw new InvalidOperationException($"Could not open connection to '{resource.Name}'"); 278var configStoreFilename = aspireStore.GetFileNameWithContent($"{builder.Resource.Name}-config.user.inc.php", tempConfigFile); 409writer.WriteLine($"$cfg['Servers'][$i]['verbose'] = '{mySqlInstance.Name}';");

MySqlServerResource.cs (1)

117_databases.TryAdd(database.Name, database.DatabaseName);

AddMySqlTests.cs (5)

47Assert.Equal("mysql", containerResource.Name); 229Assert.Single(builder.Resources.OfType<ContainerResource>(), resource => resource.Name == "phpmyadmin"); 251Assert.Equal($"{mysql.Resource.Name}:{mysql.Resource.PrimaryEndpoint.TargetPort}", config["PMA_HOST"]); 283string pattern1 = $@"\$cfg\['Servers'\]\[\$i\]\['host'\] = '{mysql1.Resource.Name}:{mysql1.Resource.PrimaryEndpoint.TargetPort}';"; 284string pattern2 = $@"\$cfg\['Servers'\]\[\$i\]\['host'\] = '{mysql2.Resource.Name}:{mysql2.Resource.PrimaryEndpoint.TargetPort}';";

MySqlFunctionalTests.cs (29)

NatsBuilderExtensions.cs (1)

67?? throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{nats.Name}' resource but the connection string was null.");

AddNatsTests.cs (2)

102Assert.Equal("nats", containerResource.Name); 144Assert.Equal("nats", containerResource.Name);

NatsFunctionalTests.cs (14)

35await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name); 40hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = await nats.Resource.ConnectionStringExpression.GetValueAsync(default); 81await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name); 87hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = connectionString; 124await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name); 134hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = modifiedConnectionString; 187await app.WaitForTextAsync("Listening for client connections", nats1.Resource.Name); 193hb.Configuration[$"ConnectionStrings:{nats1.Resource.Name}"] = await nats1.Resource.ConnectionStringExpression.GetValueAsync(default); 236await app.WaitForTextAsync("Listening for client connections", nats2.Resource.Name); 242hb.Configuration[$"ConnectionStrings:{nats2.Resource.Name}"] = await nats2.Resource.ConnectionStringExpression.GetValueAsync(default); 347await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 349await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 353await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 355await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

OpenAIExtensions.cs (1)

205var healthCheckKey = $"{builder.Resource.Name}_check";

OpenAIExtensionTests.cs (5)

61Assert.Equal("chat", model.Resource.Name); 74Assert.Equal("openai-openai-apikey", parent.Resource.Key.Name); 149Assert.Equal("openai-openai-apikey", parent.Resource.Key.Name); 165Assert.Equal("test", resource.Name); 363Assert.Equal("chat", openai.Resource.Name);

OpenAIFunctionalTests.cs (8)

OracleDatabaseBuilderExtensions.cs (1)

50throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{oracleDatabaseServer.Name}' resource but the connection string was null.");

OracleFunctionalTests.cs (14)

51hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 53hb.AddOracleDatabaseDbContext<TestDbContext>(db.Resource.Name); 137hb.Configuration[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default); 139hb.AddOracleDatabaseDbContext<TestDbContext>(db1.Resource.Name); 198hb.Configuration[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default); 200hb.AddOracleDatabaseDbContext<TestDbContext>(db2.Resource.Name); 305hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 307hb.AddOracleDatabaseDbContext<TestDbContext>(db.Resource.Name); 402hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 404hb.AddOracleDatabaseDbContext<TestDbContext>(db.Resource.Name); 465await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 467await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 471await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 473await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

PostgresBuilderExtensions.cs (9)

67throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{postgresServer.Name}' resource but the connection string was null."); 75throw new DistributedApplicationException($"ResourceReadyEvent was published for the '{postgresServer.Name}' resource but the connection string was null."); 85throw new InvalidOperationException($"Could not open connection to '{postgresServer.Name}'"); 154builder.Resource.AddDatabase(postgresDatabase.Name, postgresDatabase.DatabaseName); 373containerName ??= $"{builder.Resource.Name}-mcp"; 375if (builder.ApplicationBuilder.Resources.OfType<PostgresMcpContainerResource>().FirstOrDefault(r => string.Equals(r.Name, containerName, StringComparisons.ResourceName)) is { } existing) 607host = "{postgresDatabase.Parent.Name}" 617Name = $"{postgresDatabase.Name}.toml", 644writer.WriteString("Name", postgresInstance.Name);

AddPostgresTests.cs (3)

513Assert.Equal(pg1.Resource.Name, servers.GetProperty("1").GetProperty("Name").GetString()); 525Assert.Equal(pg2.Resource.Name, servers.GetProperty("2").GetProperty("Name").GetString()); 658host = "{postgresDatabase.Parent.Name}"

PostgresFunctionalTests.cs (36)

PostgresMcpBuilderTests.cs (1)

30Assert.Equal("db-mcp", mcpContainer.Name);

PythonAppResourceBuilderExtensions.cs (6)

1305var installerName = $"{builder.Resource.Name}-installer"; 1385var venvCreatorName = $"{builder.Resource.Name}-venv-creator"; 1423var venvCreatorName = $"{builder.Resource.Name}-venv-creator"; 1438var venvCreatorName = $"{resource.Name}-venv-creator"; 1439var installerName = $"{resource.Name}-installer"; 1446builder.TryCreateResourceBuilder<PythonAppResource>(resource.Name, out var appBuilder);

AddPythonAppTests.cs (18)

AddUvicornAppTests.cs (1)

25Assert.Equal("uvicorn-app", uvicornApp.Resource.Name);

QdrantBuilderExtensions.cs (1)

56?? throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{qdrant.Name}' resource but the connection string was null.");

AddQdrantTests.cs (1)

329Assert.Equal("my-qdrant", qdrantResource.Name);

QdrantFunctionalTests.cs (10)

45[$"ConnectionStrings:{qdrant.Resource.Name}"] = await qdrant.Resource.ConnectionStringExpression.GetValueAsync(default) 48hb.AddQdrantClient(qdrant.Resource.Name); 131[$"ConnectionStrings:{qdrant1.Resource.Name}"] = await qdrant1.Resource.ConnectionStringExpression.GetValueAsync(default) 134hb.AddQdrantClient(qdrant1.Resource.Name); 177[$"ConnectionStrings:{qdrant2.Resource.Name}"] = await qdrant2.Resource.ConnectionStringExpression.GetValueAsync(default) 180hb.AddQdrantClient(qdrant2.Resource.Name); 276await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 278await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 282await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, (re => re.Snapshot.HealthStatus == HealthStatus.Healthy), cts.Token); 284await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

RabbitMQBuilderExtensions.cs (3)

52throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{rabbitMq.Name}' resource but the connection string was null."); 216throw new DistributedApplicationException($"Cannot configure the RabbitMQ resource '{builder.Resource.Name}' to enable the management plugin as it uses an unrecognized container image registry, name, or tag."); 270var nodeName = $"{builder.Resource.Name}@localhost";

AddRabbitMQTests.cs (1)

53Assert.Equal("rabbit", containerResource.Name);

RabbitMQFunctionalTests.cs (10)

41await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 43await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 47await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 49await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 70hb.Configuration[$"ConnectionStrings:{rabbitMQ.Resource.Name}"] = await rabbitMQ.Resource.ConnectionStringExpression.GetValueAsync(default); 71hb.AddRabbitMQClient(rabbitMQ.Resource.Name); 134hb.Configuration[$"ConnectionStrings:{rabbitMQ1.Resource.Name}"] = await rabbitMQ1.Resource.ConnectionStringExpression.GetValueAsync(default); 135hb.AddRabbitMQClient(rabbitMQ1.Resource.Name); 191hb.Configuration[$"ConnectionStrings:{rabbitMQ2.Resource.Name}"] = await rabbitMQ2.Resource.ConnectionStringExpression.GetValueAsync(default); 192hb.AddRabbitMQClient(rabbitMQ2.Resource.Name);

RedisBuilderExtensions.cs (6)

86throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{redis.Name}' resource but the connection string was null."); 170logger.LogError($"Cannot configure an encrypted certificate for redis resource '{redis.Name}'"); 260var hostString = $"{(hostsVariableBuilder.Length > 0 ? "," : string.Empty)}{redisInstance.Name}:{redisInstance.Name}:{endpoint.TargetPort}:0"; 327context.EnvironmentVariables[$"RI_REDIS_ALIAS{counter}"] = redisInstance.Name; 366logger.LogError($"Cannot configure an encrypted certificate for redis insight resource '{resource.Name}'");

AddRedisTests.cs (11)

40Assert.Equal("myRedis", containerResource.Name); 68Assert.Equal("myRedis", containerResource.Name); 301Assert.Equal($"{redis1.Resource.Name}.dev.internal", item.Value); 311Assert.Equal(redis1.Resource.Name, item.Value); 323Assert.Equal($"{redis2.Resource.Name}.dev.internal", item.Value); 333Assert.Equal(redis2.Resource.Name, item.Value); 345Assert.Equal($"{redis3.Resource.Name}.dev.internal", item.Value); 355Assert.Equal(redis3.Resource.Name, item.Value); 497Assert.Equal($"myredis1:{redis.Resource.Name}:6379:0:{redis.Resource.PasswordParameter?.Value}", config["REDIS_HOSTS"]); 519Assert.Equal($"myredis1:{redis.Resource.Name}:6379:0:{password}", config["REDIS_HOSTS"]); 544Assert.Equal($"myredis1:{redis1.Resource.Name}:6379:0:{redis1.Resource.PasswordParameter?.Value},myredis2:myredis2:6379:0:{redis2.Resource.PasswordParameter?.Value}", config["REDIS_HOSTS"]);

RedisFunctionalTests.cs (35)

51await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 53await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 57await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 59await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 80await app.WaitForTextAsync("Redis Connection", resourceName: commanderBuilder.Resource.Name); 82var client = app.CreateHttpClient(commanderBuilder.Resource.Name, "http"); 91var path = $"/apiv2/server/R:{redis.Resource.Name}:{endpoint.TargetPort}:0/info"; 113[$"ConnectionStrings:{redis.Resource.Name}"] = await redis.Resource.GetConnectionStringAsync() 116hb.AddRedisClient(redis.Resource.Name); 152await rns.WaitForResourceAsync(redisInsightBuilder.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 154var client = app.CreateHttpClient(redisInsightBuilder.Resource.Name, "http"); 170Assert.Equal(redis1.Resource.Name, db.Name); 171Assert.Equal($"{redis1.Resource.Name}.dev.internal", db.Host); 176Assert.Equal(redis2.Resource.Name, db.Name); 177Assert.Equal($"{redis2.Resource.Name}.dev.internal", db.Host); 182Assert.Equal(redis3.Resource.Name, db.Name); 183Assert.Equal($"{redis3.Resource.Name}.dev.internal", db.Host); 220[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true" 223hb.AddRedisClient(redis1.Resource.Name); 257[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync() 260hb.AddRedisClient(redis2.Resource.Name); 305[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true" 308hb.AddRedisClient(redis1.Resource.Name); 340[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync() 343hb.AddRedisClient(redis2.Resource.Name); 390[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true" 393hb.AddRedisClient(redis1.Resource.Name); 421[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync() 424hb.AddRedisClient(redis2.Resource.Name); 489await rns.WaitForResourceAsync(redisInsightBuilder1.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 493var httpClient = app.CreateHttpClient(redisInsightBuilder1.Resource.Name, "http"); 524await rns.WaitForResourceAsync(redisInsightBuilder2.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 528var httpClient = app.CreateHttpClient(redisInsightBuilder2.Resource.Name, "http"); 627await app.ResourceNotifications.WaitForResourceHealthyAsync(redis.Resource.Name, cts.Token); 628await app.ResourceNotifications.WaitForResourceHealthyAsync(redisCommander.Name, cts.Token);

CapabilityDispatcherTests.cs (1)

1808return $"{prefix}, {Name}!";

AddSeqTests.cs (4)

24Assert.Equal("mySeq", containerResource.Name); 52Assert.Equal("mySeq", containerResource.Name); 178Assert.Equal("mySeq", containerResource.Name); 211Assert.Equal("mySeq", containerResource.Name);

SeqFunctionalTests.cs (6)

26await app.WaitForTextAsync("Seq listening on", seq.Resource.Name); 35await app.ResourceNotifications.WaitForResourceHealthyAsync(seq.Resource.Name, default); 104await app.WaitForTextAsync("Seq listening on", seq1.Resource.Name); 115await app.ResourceNotifications.WaitForResourceHealthyAsync(seq1.Resource.Name, default); 143await app.WaitForTextAsync("Seq listening on", seq2.Resource.Name); 154await app.ResourceNotifications.WaitForResourceHealthyAsync(seq2.Resource.Name, default);

SqlServerBuilderExtensions.cs (3)

69throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{sqlServer.Name}' resource but the connection string was null."); 76throw new DistributedApplicationException($"ResourceReadyEvent was published for the '{sqlServer.Name}' resource but the connection string was null."); 84throw new InvalidOperationException($"Could not open connection to '{sqlServer.Name}'");

SqlServerServerResource.cs (1)

146_databases.TryAdd(database.Name, database.DatabaseName);

AddSqlServerTests.cs (1)

46Assert.Equal("sqlserver", containerResource.Name);

SqlServerFunctionalTests.cs (26)

43await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 45await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 49await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 51await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 81hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default); 83hb.AddSqlServerDbContext<TestDbContext>(newDb.Resource.Name); 84hb.AddSqlServerClient(newDb.Resource.Name); 181await app1.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 190[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default), 193hb1.AddSqlServerClient(db1.Resource.Name); 267await app2.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token); 276[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default), 279hb2.AddSqlServerClient(db2.Resource.Name); 373hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default); 375hb.AddSqlServerClient(newDb.Resource.Name); 381await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 427hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default); 429hb.AddSqlServerClient(newDb.Resource.Name); 435await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 500hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default); 502hb.AddSqlServerClient(newDb.Resource.Name); 508await app.ResourceNotifications.WaitForResourceHealthyAsync(sqlserver.Resource.Name, cts.Token); 561hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 562hb.AddKeyedSqlServerClient(db.Resource.Name); 571await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 573var conn = host.Services.GetRequiredKeyedService<SqlConnection>(db.Resource.Name);

TestingBuilderTests.cs (1)

168Assert.Contains(appModel.GetProjectResources(), p => p.Name == "myworker1");

TestingFactoryTests.cs (1)

44Assert.Contains(appModel.GetProjectResources(), p => p.Name == "myworker1");

AddConnectionStringTests.cs (1)

30Assert.Equal("mycs", connectionStringResource.Name);

AddParameterTests.cs (9)

ApplicationModel\Docker\WithDockerfileBuilderTests.cs (2)

289Assert.Equal("mycontainer", container.Resource.Name); 310Assert.Equal("mycontainer", container.Resource.Name);

Codespaces\CodespacesUrlRewriterTests.cs (1)

81resource.Resource.Name,

ContainerRegistryResourceTests.cs (9)

23Assert.Equal("docker-hub", registry.Resource.Name); 39Assert.Equal("acr", registry.Resource.Name); 57Assert.Equal("my-registry", registry.Resource.Name); 74Assert.Equal("my-registry", registry.Resource.Name); 158Assert.Equal("docker-hub", registry.Name); 190Assert.Equal("my-registry", registry.Name); 295Assert.Contains(registries, r => r.Name == "docker-hub"); 296Assert.Contains(registries, r => r.Name == "ghcr"); 297Assert.Contains(registries, r => r.Name == "acr");

ContainerTunnelTests.cs (2)

37using var clientA = app.CreateHttpClient(yarp.Resource.Name, "http"); 77using var clientA = app.CreateHttpClient(yarp.Resource.Name, "http");

Dashboard\DashboardResourceTests.cs (4)

56Assert.Equal("aspire-dashboard", dashboard.Name); 267Assert.Equal("aspire-dashboard", dashboard.Name); 601Assert.Equal("aspire-dashboard", dashboard.Name); 656Assert.Equal("aspire-dashboard", dashboard.Name);

Dashboard\DashboardServiceTests.cs (1)

176await dashboardServiceData.WaitForResourceAsync(testResource.Name, r =>

Dcp\DcpExecutorTests.cs (5)

2282.Where(c => c.AppModelResourceName == container.Resource.Name) 2299await AssertEndpoint(container.Resource, "proxied", KnownNetworkIdentifiers.DefaultAspireContainerNetwork, $"{container.Resource.Name}.dev.internal", 11234); 2300await AssertEndpoint(container.Resource, "notProxied", KnownNetworkIdentifiers.DefaultAspireContainerNetwork, $"{container.Resource.Name}.dev.internal", 18765); 2305await AssertEndpoint(containerWithAlias.Resource, "proxied", KnownNetworkIdentifiers.DefaultAspireContainerNetwork, $"{containerWithAlias.Resource.Name}.dev.internal", 21234); 2306await AssertEndpoint(containerWithAlias.Resource, "notProxied", KnownNetworkIdentifiers.DefaultAspireContainerNetwork, $"{containerWithAlias.Resource.Name}.dev.internal", 28765);

DistributedApplicationTests.cs (9)

636using var clientA = app.CreateHttpClient(testProgram.ServiceABuilder.Resource.Name, "http"); 637using var clientC = app.CreateHttpClient(testProgram.ServiceCBuilder.Resource.Name, "http"); 644var uri = app.GetEndpoint(testProgram.ServiceBBuilder.Resource.Name, "http"); 962var dependentRunningResourceEvent = await rns.WaitForResourceAsync(container.Resource.Name, e => e.Snapshot.State?.Text == KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 1564await app.WaitForTextAsync("Content root path:", resourceName: testProgram.ServiceABuilder.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutDuration); 1567var httpEndPoint = app.GetEndpoint(testProgram.ServiceABuilder.Resource.Name, endpointName: "http"); 1585var httpsEndpoint = app.GetEndpoint(testProgram.ServiceABuilder.Resource.Name, endpointName: "https"); 1635using var clientA = app.CreateHttpClient(servicea.Resource.Name, "http"); 1704using var clientA = app.CreateHttpClient(servicea.Resource.Name, "http");

ExpressionResolverTests.cs (1)

297return new ValueTask<string?>(base.Name);

ExternalServiceTests.cs (14)

Health\ResourceHealthCheckServiceTests.cs (2)

233await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, abortTokenSource.Token).DefaultTimeout(); 317await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, abortTokenSource.Token).DefaultTimeout();

HealthCheckTests.cs (4)

104await rns.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 106await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 110await rns.WaitForResourceHealthyAsync(resource.Resource.Name).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 112await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout);

Orchestrator\ApplicationOrchestratorTests.cs (5)

404await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, parentResource.Resource, parentResource.Resource.Name)); 632var childContainerState = resourceNotificationService.TryGetCurrentState(childContainer.Resource.Name, out var childContainerEvent) ? childContainerEvent.Snapshot.State?.Text : null; 633var customChildState = resourceNotificationService.TryGetCurrentState(customChild.Resource.Name, out var customChildEvent) ? customChildEvent.Snapshot.State?.Text : null; 679var childProjectState = resourceNotificationService.TryGetCurrentState(childProject.Resource.Name, out var childProjectEvent) ? childProjectEvent.Snapshot.State?.Text : null; 680var customChildState = resourceNotificationService.TryGetCurrentState(customChild.Resource.Name, out var customChildEvent) ? customChildEvent.Snapshot.State?.Text : null;

Orchestrator\ParameterProcessorTests.cs (6)

594var explicitParameterResource = model.Resources.OfType<ParameterResource>().First(p => p.Name == "explicitParam"); 595var referencedParameterResource = model.Resources.OfType<ParameterResource>().First(p => p.Name == "referencedParam"); 640Assert.Equal("explicitParam", explicitParameterResource.Name); 666Assert.Equal("envParam", parameterResource.Name); 845Assert.Equal("excludedParam", parameterResource.Name); 1466var section = await capturingStateManager.AcquireSectionAsync($"Parameters:{parameter.Name}").DefaultTimeout();

Pipelines\DistributedApplicationPipelineTests.cs (1)

2096var paramResource = builder.Resources.OfType<ParameterResource>().FirstOrDefault(p => p.Name == "test-param");

ProjectResourceTests.cs (2)

133Assert.Equal("projectName", resource.Name); 242Assert.Equal("projectName", resource.Name);

PublishAsDockerfileTests.cs (9)

29Assert.Equal("frontend", containerResource.Name); 75Assert.Equal("frontend", containerResource.Name); 124Assert.Equal("frontend", containerResource.Name); 173Assert.Equal("frontend", containerResource.Name); 233Assert.Equal("project", containerResource.Name); 372Assert.Equal("frontend", containerResource.Name); 398Assert.Equal("frontend", containerResource.Name); 418Assert.Equal("project", containerResource.Name); 445Assert.Equal("project", containerResource.Name);

ResourceLoggerServiceTests.cs (3)

86Assert.Empty(service.GetResourceLoggerState(testResource.Name).GetBacklogSnapshot()); 136service.ClearBacklog(testResource.Name); 199Assert.Empty(service.GetResourceLoggerState(testResource.Name).GetBacklogSnapshot());

SlimTestProgramTests.cs (3)

36using var clientA = app.CreateHttpClientWithResilience(testProgram.ServiceABuilder.Resource.Name, "http"); 39using var clientB = app.CreateHttpClientWithResilience(testProgram.ServiceBBuilder.Resource.Name, "http"); 42using var clientC = app.CreateHttpClientWithResilience(testProgram.ServiceCBuilder.Resource.Name, "http");

TestProgramFixture.cs (3)

68using var clientA = App.CreateHttpClientWithResilience(TestProgram.ServiceABuilder.Resource.Name, "http"); 72using var clientB = App.CreateHttpClientWithResilience(TestProgram.ServiceBBuilder.Resource.Name, "http"); 76using var clientC = App.CreateHttpClientWithResilience(TestProgram.ServiceCBuilder.Resource.Name, "http");

WaitForTests.cs (37)

WithEndpointTests.cs (1)

217Assert.Equal("foo", resource.Name);

WithHttpCommandTests.cs (8)

97Assert.Equal($"{resourceBuilder.Resource.Name}-http-http-post-/some-path", command.Name); 302await app.ResourceNotifications.WaitForResourceAsync(serviceA.Resource.Name, KnownResourceStates.Running).DefaultTimeout(); 335Assert.Equal(service.Resource.Name, requestContext.ResourceName); 379Assert.Equal(service.Resource.Name, resultContext.ResourceName); 425service.Resource.Name, 438service.Resource.Name, 481service.Resource.Name, 496service.Resource.Name,

WithUrlsTests.cs (7)

267Assert.StartsWith($"http://{projectB.Resource.Name.ToLowerInvariant()}{expectedHostSuffix}", u.Url); 387servicea.Resource.Name, 414servicea.Resource.Name, 447servicea.Resource.Name, 498await rns.WaitForResourceAsync(servicea.Resource.Name, KnownResourceStates.Running, cts.Token); 616await rns.WaitForResourceAsync(custom.Resource.Name, KnownResourceStates.Running, cts.Token); 979resourceB.Resource.Name,

ValkeyBuilderExtensions.cs (1)

135throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{valkey.Name}' resource but the connection string was null.");

AddValkeyTests.cs (2)

25Assert.Equal("myValkey", containerResource.Name); 53Assert.Equal("myValkey", containerResource.Name);

ValkeyFunctionalTests.cs (10)

37[$"ConnectionStrings:{valkey.Resource.Name}"] = await valkey.Resource.ConnectionStringExpression.GetValueAsync(default) 40hb.AddRedisClient(valkey.Resource.Name); 101[$"ConnectionStrings:{valkey1.Resource.Name}"] = $"{await valkey1.Resource.ConnectionStringExpression.GetValueAsync(default)},allowAdmin=true" 104hb.AddRedisClient(valkey1.Resource.Name); 153[$"ConnectionStrings:{valkey2.Resource.Name}"] = await valkey2.Resource.ConnectionStringExpression.GetValueAsync(default) 156hb.AddRedisClient(valkey2.Resource.Name); 225await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 227await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 231await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 233await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

ConfigurationBuilder\YarpCluster.cs (1)

46: this(externalService.Name, GetAddressFromExternalService(externalService))

YarpFunctionalTests.cs (3)

49await app.ResourceNotifications.WaitForResourceHealthyAsync(backend.Resource.Name, cts.Token); 50await app.ResourceNotifications.WaitForResourceHealthyAsync(yarp.Resource.Name, cts.Token); 52using var httpClient = app.CreateHttpClient(yarp.Resource.Name);

Infrastructure\DistributedApplicationExtensions.cs (3)

32builder.Configuration[$"Parameters:{parameter.Name}"] = parameter.Secret 218using (var checkHttpClient = app.CreateHttpClient(project.Name)) 246using var applyMigrationsHttpClient = app.CreateHttpClient(project.Name, useHttpClientFactory: false);

TestResource.cs (2)

52logger.LogInformation("Starting test resource {ResourceName} with update interval {Interval} seconds", resource.Name, seconds); 70logger.LogInformation("Test resource {ResourceName} is now in state {State}", resource.Name, randomState);

AppHost.cs (2)

16Label = p.Name, 17Placeholder = $"Enter value for {p.Name}",

Program.cs (2)

11.WithArgs(kafka.Resource.Name); 15.WithArgs(kafka.Resource.Name);

DistributedApplicationPipelineExtensions.cs (3)

66var publishTask = await context.ReportingStep.CreateTaskAsync($"Publishing {projectResource.Name}", cancellationToken).ConfigureAwait(false); 122var uploadTask = await context.ReportingStep.CreateTaskAsync($"Uploading to {projectResource.Name}", cancellationToken).ConfigureAwait(false); 127var siteName = websiteResource.Outputs[$"{Infrastructure.NormalizeBicepIdentifier(websiteResource.Name)}_name"]?.ToString();

TestResource.cs (2)

71logger.LogInformation("Starting test resource {ResourceName} with update interval {Interval} seconds", resource.Name, seconds); 89logger.LogInformation("Test resource {ResourceName} is now in state {State}", resource.Name, randomState);

WaitFailures.cs (14)

TestProgram.cs (1)

179root[project.Name] = projectJson;