public async Task <object> Execute(Recommendation recommendation, OptionSettingItem optionSetting)
{
var currentValue = recommendation.GetOptionSettingValue(optionSetting);
var keyPairs = await _awsResourceQueryer.ListOfEC2KeyPairs(_session);
var userInputConfiguration = new UserInputConfiguration <KeyPairInfo>
{
DisplaySelector = kp => kp.KeyName,
DefaultSelector = kp => kp.KeyName.Equals(currentValue),
AskNewName = true,
EmptyOption = true,
CurrentValue = currentValue
};
var settingValue = "";
while (true)
{
var userResponse = _consoleUtilities.AskUserToChooseOrCreateNew(keyPairs, "Select key pair to use:", userInputConfiguration);
if (userResponse.IsEmpty)
{
settingValue = "";
break;
}
else
{
settingValue = userResponse.SelectedOption?.KeyName ?? userResponse.NewName;
}
if (userResponse.CreateNew && !string.IsNullOrEmpty(userResponse.NewName))
{
_toolInteractiveService.WriteLine(string.Empty);
_toolInteractiveService.WriteLine("You have chosen to create a new key pair.");
_toolInteractiveService.WriteLine("You are required to specify a directory to save the key pair private key.");
var answer = _consoleUtilities.AskYesNoQuestion("Do you want to continue?", "false");
if (answer == ConsoleUtilities.YesNo.No)
{
continue;
}
_toolInteractiveService.WriteLine(string.Empty);
_toolInteractiveService.WriteLine($"A new key pair will be created with the name {settingValue}.");
var keyPairDirectory = _consoleUtilities.AskForEC2KeyPairSaveDirectory(recommendation.ProjectPath);
await _awsResourceQueryer.CreateEC2KeyPair(_session, settingValue.ToString(), keyPairDirectory);
}
break;
}
return(settingValue);
}
public async Task <object> Execute(Recommendation recommendation, OptionSettingItem optionSetting)
{
var currentValue = recommendation.GetOptionSettingValue(optionSetting);
var platformArns = await _awsResourceQueryer.GetElasticBeanstalkPlatformArns(_session);
var userInputConfiguration = new UserInputConfiguration <PlatformSummary>
{
DisplaySelector = platform => $"{platform.PlatformBranchName} v{platform.PlatformVersion}",
DefaultSelector = platform => platform.PlatformArn.Equals(currentValue),
CreateNew = false
};
var userResponse = _consoleUtilities.AskUserToChooseOrCreateNew(platformArns, "Select the Platform to use:", userInputConfiguration);
return(userResponse.SelectedOption?.PlatformArn);
}
public async Task <object> Execute(Recommendation recommendation, OptionSettingItem optionSetting)
{
var currentValue = recommendation.GetOptionSettingValue(optionSetting);
var applicationOptionSetting = recommendation.GetOptionSetting(optionSetting.ParentSettingId);
var applicationName = recommendation.GetOptionSettingValue(applicationOptionSetting) as string;
var environments = await _awsResourceQueryer.ListOfElasticBeanstalkEnvironments(_session, applicationName);
var userResponse = _consoleUtilities.AskUserToChooseOrCreateNew(
options: environments.Select(env => env.EnvironmentName),
title: "Select Elastic Beanstalk environment to deploy to:",
askNewName: true,
defaultNewName: currentValue.ToString());
return(userResponse.SelectedOption ?? userResponse.NewName);
}
public async Task <object> Execute(Recommendation recommendation, OptionSettingItem optionSetting)
{
var currentVpcTypeHintResponse = optionSetting.GetTypeHintData <VpcTypeHintResponse>();
var vpcs = await _awsResourceQueryer.GetListOfVpcs(_session);
var userInputConfig = new UserInputConfiguration <Vpc>
{
DisplaySelector = vpc =>
{
var name = vpc.Tags?.FirstOrDefault(x => x.Key == "Name")?.Value ?? string.Empty;
var namePart =
string.IsNullOrEmpty(name)
? ""
: $" ({name}) ";
var isDefaultPart =
vpc.IsDefault
? " *** Account Default VPC ***"
: "";
return($"{vpc.VpcId}{namePart}{isDefaultPart}");
},
DefaultSelector = vpc =>
!string.IsNullOrEmpty(currentVpcTypeHintResponse?.VpcId)
? vpc.VpcId == currentVpcTypeHintResponse.VpcId
: vpc.IsDefault
};
var userResponse = _consoleUtilities.AskUserToChooseOrCreateNew(
vpcs,
"Select a VPC",
userInputConfig);
return(new VpcTypeHintResponse
{
IsDefault = userResponse.SelectedOption?.IsDefault == true,
CreateNew = userResponse.CreateNew,
VpcId = userResponse.SelectedOption?.VpcId ?? ""
});
}
public async Task <object> Execute(Recommendation recommendation, OptionSettingItem optionSetting)
{
var typeHintData = optionSetting.GetTypeHintData <IAMRoleTypeHintData>();
var existingRoles = await _awsResourceQueryer.ListOfIAMRoles(_session, typeHintData?.ServicePrincipal);
var currentTypeHintResponse = recommendation.GetOptionSettingValue <IAMRoleTypeHintResponse>(optionSetting);
var userInputConfiguration = new UserInputConfiguration <Role>
{
DisplaySelector = role => role.RoleName,
DefaultSelector = role => currentTypeHintResponse.RoleArn?.Equals(role.Arn) ?? false,
};
var userResponse = _consoleUtilities.AskUserToChooseOrCreateNew(existingRoles, "Select an IAM role", userInputConfiguration);
return(new IAMRoleTypeHintResponse
{
CreateNew = userResponse.CreateNew,
RoleArn = userResponse.SelectedOption?.Arn
});
}
public async Task <object> Execute(Recommendation recommendation, OptionSettingItem optionSetting)
{
var applications = await _awsResourceQueryer.ListOfElasticBeanstalkApplications(_session);
var currentTypeHintResponse = recommendation.GetOptionSettingValue <BeanstalkApplicationTypeHintResponse>(optionSetting);
var userInputConfiguration = new UserInputConfiguration <ApplicationDescription>
{
DisplaySelector = app => app.ApplicationName,
DefaultSelector = app => app.ApplicationName.Equals(currentTypeHintResponse?.ApplicationName),
AskNewName = true,
DefaultNewName = currentTypeHintResponse.ApplicationName
};
var userResponse = _consoleUtilities.AskUserToChooseOrCreateNew(applications, "Select Elastic Beanstalk application to deploy to:", userInputConfiguration);
return(new BeanstalkApplicationTypeHintResponse
{
CreateNew = userResponse.CreateNew,
ApplicationName = userResponse.SelectedOption?.ApplicationName ?? userResponse.NewName
});
}
public async Task <object> Execute(Recommendation recommendation, OptionSettingItem optionSetting)
{
var clusters = await _awsResourceQueryer.ListOfECSClusters(_session);
var currentTypeHintResponse = recommendation.GetOptionSettingValue <ECSClusterTypeHintResponse>(optionSetting);
var userInputConfiguration = new UserInputConfiguration <Cluster>
{
DisplaySelector = cluster => cluster.ClusterName,
DefaultSelector = cluster => cluster.ClusterArn.Equals(currentTypeHintResponse?.ClusterArn),
AskNewName = true,
DefaultNewName = currentTypeHintResponse.NewClusterName
};
var userResponse = _consoleUtilities.AskUserToChooseOrCreateNew(clusters, "Select ECS cluster to deploy to:", userInputConfiguration);
return(new ECSClusterTypeHintResponse
{
CreateNew = userResponse.CreateNew,
ClusterArn = userResponse.SelectedOption?.ClusterArn ?? string.Empty,
NewClusterName = userResponse.NewName
});
}
public async Task ExecuteAsync(bool saveCdkProject)
{
// Ensure a .NET project can be found.
ProjectDefinition project = null;
try
{
project = new ProjectDefinition(_session.ProjectPath);
}
catch (ProjectFileNotFoundException ex)
{
var files = Directory.GetFiles(_session.ProjectPath, "*.sln");
if (files.Any())
{
_toolInteractiveService.WriteErrorLine($"This directory contains a solution file, but the tool requires a project file. Please run the tool from the directory that contains a .csproj/.fsproj or provide a path to the .csproj/.fsproj via --project-path flag.");
}
else
{
_toolInteractiveService.WriteErrorLine($"A project was not found at the path {_session.ProjectPath}");
}
throw new FailedToFindDeployableTargetException(ex);
}
var orchestrator =
new Orchestrator.Orchestrator(
_session,
_orchestratorInteractiveService,
_cdkProjectHandler,
_awsResourceQueryer,
_deploymentBundleHandler,
new[] { RecipeLocator.FindRecipeDefinitionsPath() });
// Determine what recommendations are possible for the project.
var recommendations = await orchestrator.GenerateDeploymentRecommendations();
if (recommendations.Count == 0)
{
_toolInteractiveService.WriteLine(string.Empty);
_toolInteractiveService.WriteErrorLine($"The project you are trying to deploy is currently not supported.");
throw new FailedToGenerateAnyRecommendations();
}
// Look to see if there are any existing deployed applications using any of the compatible recommendations.
var existingApplications = await orchestrator.GetExistingDeployedApplications(recommendations);
_toolInteractiveService.WriteLine(string.Empty);
string cloudApplicationName;
if (existingApplications.Count == 0)
{
var title = "Name the AWS stack to deploy your application to" + Environment.NewLine +
"(A stack is a collection of AWS resources that you can manage as a single unit.)" + Environment.NewLine +
"--------------------------------------------------------------------------------";
cloudApplicationName =
_consoleUtilities.AskUserForValue(
title,
GetDefaultApplicationName(project.ProjectPath),
allowEmpty: false);
}
else
{
var title = "Select the AWS stack to deploy your application to" + Environment.NewLine +
"(A stack is a collection of AWS resources that you can manage as a single unit.)";
var userResponse = _consoleUtilities.AskUserToChooseOrCreateNew(existingApplications.Select(x => x.Name).ToList(), title, askNewName: true, defaultNewName: GetDefaultApplicationName(project.ProjectPath));
cloudApplicationName = userResponse.SelectedOption ?? userResponse.NewName;
}
var existingCloudApplication = existingApplications.FirstOrDefault(x => string.Equals(x.Name, cloudApplicationName));
Recommendation selectedRecommendation = null;
_toolInteractiveService.WriteLine(string.Empty);
// If using a previous deployment preset settings for deployment based on last deployment.
if (existingCloudApplication != null)
{
var existingCloudApplicationMetadata = await orchestrator.LoadCloudApplicationMetadata(existingCloudApplication.Name);
selectedRecommendation = recommendations.FirstOrDefault(x => string.Equals(x.Recipe.Id, existingCloudApplication.RecipeId, StringComparison.InvariantCultureIgnoreCase));
selectedRecommendation.ApplyPreviousSettings(existingCloudApplicationMetadata.Settings);
var header = $"Loading {existingCloudApplication.Name} settings:";
_toolInteractiveService.WriteLine(header);
_toolInteractiveService.WriteLine(new string('-', header.Length));
var optionSettings =
selectedRecommendation
.Recipe
.OptionSettings
.Where(x =>
{
if (!selectedRecommendation.IsOptionSettingDisplayable(x))
{
return(false);
}
var value = selectedRecommendation.GetOptionSettingValue(x);
if (value == null || value.ToString() == string.Empty || object.Equals(value, x.DefaultValue))
{
return(false);
}
return(true);
})
.ToArray();
foreach (var setting in optionSettings)
{
DisplayOptionSetting(selectedRecommendation, setting, -1, optionSettings.Length, DisplayOptionSettingsMode.Readonly);
}
}
else
{
selectedRecommendation = _consoleUtilities.AskToChooseRecommendation(recommendations);
}
// Apply the user enter project name to the recommendation so that any default settings based on project name are applied.
selectedRecommendation.OverrideProjectName(cloudApplicationName);
var systemCapabilities = await _session.SystemCapabilities;
if (selectedRecommendation.Recipe.DeploymentType == DeploymentTypes.CdkProject &&
!systemCapabilities.NodeJsMinVersionInstalled)
{
_toolInteractiveService.WriteErrorLine("The selected deployment option requires Node.js 10.3 or later, which was not detected. Please install Node.js: https://nodejs.org/en/download/");
throw new MissingNodeJsException();
}
if (selectedRecommendation.Recipe.DeploymentBundle == DeploymentBundleTypes.Container)
{
if (!systemCapabilities.DockerInfo.DockerInstalled)
{
_toolInteractiveService.WriteErrorLine("The selected deployment option requires Docker, which was not detected. Please install and start the appropriate version of Docker for you OS: https://docs.docker.com/engine/install/");
throw new MissingDockerException();
}
if (!systemCapabilities.DockerInfo.DockerContainerType.Equals("linux", StringComparison.OrdinalIgnoreCase))
{
_toolInteractiveService.WriteErrorLine("The deployment tool requires Docker to be running in linux mode. Please switch Docker to linux mode to continue.");
throw new DockerContainerTypeException();
}
}
var deploymentBundleDefinition = orchestrator.GetDeploymentBundleDefinition(selectedRecommendation);
var configurableOptionSettings = selectedRecommendation.Recipe.OptionSettings.Union(deploymentBundleDefinition.Parameters);
await ConfigureDeployment(selectedRecommendation, configurableOptionSettings, false);
var cloudApplication = new CloudApplication
{
Name = cloudApplicationName
};
if (!ConfirmDeployment(selectedRecommendation))
{
return;
}
await CreateDeploymentBundle(orchestrator, selectedRecommendation, cloudApplication);
await orchestrator.DeployRecommendation(cloudApplication, selectedRecommendation);
}