public Task <SolutionComponent> InitializeAt(
Components.ComponentTree tree,
ComponentData data,
ProjectSettings settings)
{
throw new System.NotImplementedException();
}
public async Task <ClientComponent> InitializeAt(
Components.ComponentTree tree,
ComponentData data,
ProjectSettings settings)
{
var configFile = Path.Combine(tree.Path.FullName, ClientComponent.ConfigFileName);
if (File.Exists(configFile))
{
throw new InvalidOperationException($"You can't create a client at \"{tree.Path.FullName}\". It already exists.");
}
var clientPort = data.Port ?? ProjectSettings.GetRandomUnusedPort();
await TypeHandlers[data.ClientType](tree.Path, settings, data.Name);
await Templates.Extract(
ClientComponent.ConfigFileName,
configFile,
Templates.TemplateType.Infrastructure,
("NAME", TemplateData.SanitizeResourceName(data.Name)),
("PORT", clientPort.ToString()),
("TYPE", data.ClientType.ToString()),
("PATH", settings.GetRelativePath(
tree.Path.FullName,
tree.FindFirst <TerraformRootComponent>(Components.Direction.Out)?.FoundAt.Path.FullName)));
return(await ClientComponent.Init(tree.Path, x => CreateBaseContainer(tree.Path, settings, x.Name), settings));
}
public async Task <ApiGatewayComponent> InitializeAt(
Components.ComponentTree tree,
ComponentData data,
ProjectSettings settings)
{
var configPath = Path.Combine(tree.Path.FullName, ApiGatewayComponent.ConfigFileName);
if (File.Exists(configPath))
{
throw new InvalidOperationException($"You can't add a new api at: \"{tree.Path.FullName}\". It already exists.");
}
var port = data.Port ?? ProjectSettings.GetRandomUnusedPort();
await Templates.Extract(
ApiGatewayComponent.ConfigFileName,
configPath,
Templates.TemplateType.Infrastructure,
("API_NAME", TemplateData.SanitizeResourceName(data.Name)),
("PORT", port.ToString()),
("DEFAULT_LANGUAGE", data.DefaultLanguage),
("BASE_URL", data.BaseUrl));
return(await ApiGatewayComponent.Init(tree.Path, settings));
}
public async Task <TemplateData> GetCloudformationData(Components.ComponentTree components)
{
var template = (await components
.FindAll <ICloudformationComponent>(Components.Direction.In)
.Select(x => x.component?.GetCloudformationData(x.tree))
.WhenAll())
.Merge();
var currentTemplate = new TemplateData();
foreach (var configOverride in _configuration.Overrides)
{
var matchingResources = template
.Resources
.Where(x => x.Value.Type == configOverride.Type)
.ToImmutableList();
foreach (var resource in matchingResources)
{
currentTemplate.Resources[resource.Key] = new TemplateData.ResourceData
{
Type = resource.Value.Type,
Properties = configOverride.Properties
};
}
}
return(currentTemplate);
}
public async Task <CloudformationStackComponent> InitializeAt(
Components.ComponentTree tree,
ComponentData data,
ProjectSettings settings)
{
var configFilePath = Path.Combine(tree.Path.FullName, CloudformationStackComponent.ConfigFileName);
if (File.Exists(configFilePath))
{
throw new InvalidCastException($"There is already a cloudformation stack configured at: \"{tree.Path.FullName}\"");
}
var serializer = new Serializer();
var configuration = new CloudformationStackComponent.CloudformationStackConfiguration
{
Name = data.Name,
Settings = new CloudformationStackComponent.CloudformationStackConfiguration.CloudformationStackSettings
{
Services = data.Services.ToList(),
MainPort = data.MainPort,
ServicesPort = data.ServicesPort,
DeploymentBucketName = $"{settings.GetProjectName()}-{data.Name}-deployments",
DeploymentStackName = $"{settings.GetProjectName()}-{data.Name}-deployments",
AwsRegion = data.AwsRegion
}
};
await File.WriteAllTextAsync(
configFilePath,
serializer.Serialize(configuration));
return(await CloudformationStackComponent.Init(tree, settings));
}
public async Task <CloudflareWorkerComponent> InitializeAt(
Components.ComponentTree tree,
ComponentData data,
ProjectSettings settings)
{
var configFilePath = Path.Combine(tree.Path.FullName, CloudflareWorkerComponent.ConfigFileName);
if (File.Exists(configFilePath))
{
throw new InvalidOperationException($"There is already a cloudflare worker at {tree.Path.FullName}");
}
var configuration = new CloudflareWorkerComponent.CloudflareWorkerConfiguration
{
Name = data.Name,
Settings = new CloudflareWorkerComponent.CloudflareWorkerConfiguration.CloudflareWorkerSettings
{
Port = data.Port ?? ProjectSettings.GetRandomUnusedPort(),
DestinationPort = data.DestinationPort
}
};
var serializer = new Serializer();
await File.WriteAllTextAsync(configFilePath, serializer.Serialize(configuration));
var executingAssembly = Assembly.GetExecutingAssembly();
await Directories.Copy(
Path.Combine(executingAssembly.GetPath(), "Source/CloudflareWorker"),
tree.Path.FullName,
("WORKER_NAME", data.Name));
return(await CloudflareWorkerComponent.Init(tree.Path, settings));
}
public Task <IImmutableList <PackageResource> > GetPackageResources(
Components.ComponentTree components,
string version)
{
async Task <IImmutableList <PackageResource> > GetFrom(DirectoryInfo directory)
{
var result = new List <PackageResource>();
foreach (var file in directory.GetFiles())
{
result.Add(new PackageResource(
_settings.GetRelativePath(file.FullName, components.Path.FullName),
await File.ReadAllBytesAsync(file.FullName)));
}
foreach (var subDirectory in directory.GetDirectories())
{
result.AddRange(await GetFrom(subDirectory));
}
return(result.ToImmutableList());
}
return(GetFrom(_directory));
}
public async Task <TemplateData> GetCloudformationData(Components.ComponentTree components)
{
var deserializer = new Deserializer();
return(deserializer.Deserialize <TemplateData>(
await File.ReadAllTextAsync(Path.Combine(_path.FullName, _fileName))));
}
public Task <IImmutableList <IComponent> > FindAt(Components.ComponentTree components, ProjectSettings settings)
{
var result = from file in components.Path.EnumerateFiles()
where file.Name.EndsWith(".sln")
select new SolutionComponent(file, settings);
return(Task.FromResult <IImmutableList <IComponent> >(result.OfType <IComponent>().ToImmutableList()));
}
public Task <IImmutableList <IComponent> > FindAt(Components.ComponentTree components, ProjectSettings settings)
{
var result = from directory in components.Path.EnumerateDirectories()
where directory.Name.EndsWith(".include")
select new PackageDirectoryComponent(directory, settings);
return(Task.FromResult <IImmutableList <IComponent> >(result.OfType <IComponent>().ToImmutableList()));
}
GetRequiredConfigurations(Components.ComponentTree components)
{
return(Task.FromResult <IEnumerable <(string key, string question, INeedConfiguration.ConfigurationType configurationType)> >(
new List <(string key, string question, INeedConfiguration.ConfigurationType configurationType)>
{
("localstackApiKey", "Enter your localstack api key if you have any:",
INeedConfiguration.ConfigurationType.User)
}));
}
public Task <TemplateData> GetCloudformationData(Components.ComponentTree components)
{
var template = _configuration.Settings.Template;
var functionPath = _settings.GetRelativePath(_path.FullName);
var languageVersion = _configuration.GetLanguage();
return(Task.FromResult(template.SetCodeUris(languageVersion.GetFunctionOutputPath(functionPath))));
}
public async Task <IImmutableList <PackageResource> > GetPackageResources(
Components.ComponentTree components,
string version)
{
var tempDir = new DirectoryInfo(Path.Combine(_path.FullName, ".tmp"));
if (tempDir.Exists)
{
tempDir.Delete(true);
}
tempDir.Create();
var distFolder = new DirectoryInfo(Path.Combine(_sourcePath.FullName, "dist"));
async Task AddFilesFrom(DirectoryInfo directory, ZipOutputStream zipStream)
{
if (directory.FullName == tempDir.FullName)
{
return;
}
foreach (var file in directory.GetFiles())
{
zipStream.PutNextEntry(new ZipEntry(_settings.GetRelativePath(file.FullName, distFolder.FullName)));
await zipStream.WriteAsync(await File.ReadAllBytesAsync(file.FullName));
zipStream.CloseEntry();
}
foreach (var childDirectory in directory.GetDirectories())
{
await AddFilesFrom(childDirectory, zipStream);
}
}
var appFilePath = Path.Combine(tempDir.FullName, "amplify-app.zip");
await using var zipFile = File.Create(appFilePath);
await using var outStream = new ZipOutputStream(zipFile);
await AddFilesFrom(distFolder, outStream);
await outStream.FlushAsync();
outStream.Close();
var result = ImmutableList.Create(new PackageResource(
_settings.GetRelativePath(Path.Combine(_path.FullName, "amplify-app.zip"), components.Path.FullName),
await File.ReadAllBytesAsync(appFilePath)));
tempDir.Delete(true);
return(result);
}
public Task <IImmutableList <IComponent> > FindAt(
Components.ComponentTree components,
ProjectSettings settings)
{
var result = from file in components.Path.EnumerateFiles()
where file.Name.Contains(".include.")
select new PackageFileComponent(Path.GetFileNameWithoutExtension(file.Name), file, settings);
return(Task.FromResult <IImmutableList <IComponent> >(result.OfType <IComponent>().ToImmutableList()));
}
public Task <IImmutableList <IComponent> > FindAt(
Components.ComponentTree components,
ProjectSettings settings)
{
var result = from file in components.Path.EnumerateFiles()
where file.Name.EndsWith(".tf") && !file.Name.EndsWith(".main.tf")
select new TerraformResourceComponent(Path.GetFileNameWithoutExtension(file.Name), file, settings);
return(Task.FromResult <IImmutableList <IComponent> >(result.OfType <IComponent>().ToImmutableList()));
}
public async Task <bool> Start(Components.ComponentTree components)
{
var buildResult = await Build();
if (!buildResult)
{
return(false);
}
return(await _configuration.GetLanguage().StartWatch(_path.FullName));
}
public Task <IImmutableList <IComponent> > FindAt(
Components.ComponentTree components,
ProjectSettings settings)
{
var result = (from file in components.Path.EnumerateFiles()
where file.Name.EndsWith(".cf.yml")
select new CloudformationComponent(components.Path, file.Name))
.Cast <IComponent>()
.ToImmutableList();
return(Task.FromResult <IImmutableList <IComponent> >(result));
}
public async Task <IImmutableList <IComponent> > FindAt(
Components.ComponentTree components,
ProjectSettings settings)
{
var apiGateway = await ApiGatewayComponent.Init(components.Path, settings);
return(apiGateway != null
? new List <IComponent>
{
apiGateway
}.ToImmutableList()
: ImmutableList <IComponent> .Empty);
}
public async Task <IImmutableList <IComponent> > FindAt(
Components.ComponentTree components,
ProjectSettings settings)
{
var component = await ClientComponent.Init(components.Path, x => CreateBaseContainer(components.Path, settings, x.Name), settings);
return(component != null
? new List <IComponent>
{
component
}.ToImmutableList()
: ImmutableList <IComponent> .Empty);
}
public async Task <IImmutableList <PackageResource> > GetPackageResources(
Components.ComponentTree components,
string version)
{
var resource = new PackageResource(
_settings.GetRelativePath(_file.FullName, components.Path.FullName),
await File.ReadAllBytesAsync(_file.FullName));
return(new List <PackageResource>
{
resource
}.ToImmutableList());
}
public async Task <IImmutableList <IComponent> > FindAt(
Components.ComponentTree components,
ProjectSettings settings)
{
var component = await CloudflareWorkerComponent.Init(components.Path, settings);
return(component != null
? new List <IComponent>
{
component
}.ToImmutableList()
: ImmutableList <IComponent> .Empty);
}
public async Task <IImmutableList <IComponent> > FindAt(Components.ComponentTree components, ProjectSettings settings)
{
var foundComponents = new List <IComponent>();
foreach (var file in components.Path.EnumerateFiles().Where(x => x.Name.EndsWith(".childconfig.yml")))
{
var component = await ChildConfigComponent.Init(file);
if (component != null)
{
foundComponents.Add(component);
}
}
return(foundComponents.ToImmutableList());
}
public async Task <TerraformRootComponent> InitializeAt(
Components.ComponentTree tree,
ComponentData data,
ProjectSettings settings)
{
var filePath = Path.Combine(tree.Path.FullName, $"{data.Name}.main.tf");
if (File.Exists(filePath))
{
throw new InvalidOperationException(
$"There is already a terraform root module named {data.Name} at {tree.Path.FullName}");
}
await File.WriteAllTextAsync(filePath, "");
return(new TerraformRootComponent(data.Name, new FileInfo(filePath)));
}
public async Task <ChildConfigComponent> InitializeAt(Components.ComponentTree tree, ComponentData data, ProjectSettings settings)
{
var configPath = new FileInfo(Path.Combine(tree.Path.FullName, $"{data.Name}.childconfig.yml"));
if (configPath.Exists)
{
throw new InvalidOperationException($"You can't add child config {data.Name} at \"{tree.Path.FullName}\". It already exists.");
}
await Templates.Extract(
"childconfig.yml",
configPath.FullName,
Templates.TemplateType.Infrastructure,
("NAME", TemplateData.SanitizeResourceName(data.Name)));
return(await ChildConfigComponent.Init(configPath));
}
public Task <PackageDirectoryComponent> InitializeAt(
Components.ComponentTree tree,
PackageDirectoryComponent.ComponentData data,
ProjectSettings settings)
{
var directory = new DirectoryInfo(Path.Combine(tree.Path.FullName, $"{data.Name}.include"));
if (directory.Exists)
{
throw new InvalidOperationException(
$"There is already a directory named {data.Name} at {tree.Path.FullName}");
}
directory.Create();
return(Task.FromResult(new PackageDirectoryComponent(directory, settings)));
}
public async Task <PackageFileComponent> InitializeAt(
Components.ComponentTree tree,
ComponentData data,
ProjectSettings settings)
{
var filePath = Path.Combine(tree.Path.FullName, data.Name);
if (File.Exists(filePath))
{
throw new InvalidOperationException(
$"There is already a file named {data.Name} at {tree.Path.FullName}");
}
await File.WriteAllTextAsync(filePath, "");
return(new PackageFileComponent(data.Name, new FileInfo(filePath), settings));
}
public async Task <IImmutableList <PackageResource> > GetPackageResources(
Components.ComponentTree components,
string version)
{
var result = new List <PackageResource>();
var distDirectory = new DirectoryInfo(Path.Combine(_path.FullName, "dist"));
foreach (var file in distDirectory.EnumerateFiles())
{
result.Add(new PackageResource(
_settings.GetRelativePath(file.FullName, components.Path.FullName),
await File.ReadAllBytesAsync(file.FullName)));
}
return(result.ToImmutableList());
}
public async Task <bool> Start(Components.ComponentTree components)
{
var watchResponse = await _watchContainer
.Detached()
.Run("watch");
if (!watchResponse)
{
return(false);
}
var startResponse = await _dockerContainer
.Port(_configuration.Settings.Port, 3000)
.Detached()
.Run("start");
return(startResponse);
}
public static async Task <CloudformationStackComponent> Init(
Components.ComponentTree components,
ProjectSettings settings)
{
if (!File.Exists(Path.Combine(components.Path.FullName, ConfigFileName)))
{
return(null);
}
var deserializer = new Deserializer();
return(new CloudformationStackComponent(
deserializer.Deserialize <CloudformationStackConfiguration>(
await File.ReadAllTextAsync(Path.Combine(components.Path.FullName, ConfigFileName))),
settings,
components.Path,
settings,
components));
}
public async Task <bool> Start(Components.ComponentTree components)
{
var restoreSuccess = await Restore();
if (!restoreSuccess)
{
return(false);
}
var parsers = components
.FindAll <IParseCloudformationValues>(Components.Direction.Out)
.Select(x => x.component)
.ToImmutableList();
var result = new Dictionary <string, string>();
var amplifyApp =
_configuration.Settings.Template.Resources.Values.FirstOrDefault(x => x.Type == "AWS::Amplify::App");
if (amplifyApp != null && amplifyApp.Properties.ContainsKey("EnvironmentVariables"))
{
var environmentVariables = (amplifyApp.Properties["EnvironmentVariables"] as IEnumerable <object> ?? new List <object>()).OfType <IDictionary <object, object> >();
foreach (var item in environmentVariables)
{
if (item.ContainsKey("Name") && item.ContainsKey("Value"))
{
result[item["Name"].ToString() ?? string.Empty] =
(await parsers.Parse(item["Value"])) as string;
}
}
}
var container = result.Aggregate(
_dockerContainer,
(current, variable) =>
current.EnvironmentVariable(variable.Key, variable.Value));
return(await container
.Detached()
.Port(_configuration.Settings.Port, 3000)
.Run("dev --hostname 0.0.0.0"));
}
