public async Task <int> RunAsync(PublishArguments args)
{
var inputPath = PathHelper.ResolvePath(args.InputFile);
var inputUri = PathHelper.FilePathToFileUrl(inputPath);
var configuration = this.configurationManager.GetConfiguration(inputUri);
var moduleReference = ValidateReference(args.TargetModuleReference, configuration);
if (PathHelper.HasArmTemplateLikeExtension(inputUri))
{
// Publishing an ARM template file.
using var armTemplateStream = this.fileSystem.FileStream.Create(inputPath, FileMode.Open, FileAccess.Read);
await this.PublishModuleAsync(configuration, moduleReference, armTemplateStream);
return(0);
}
var compilation = await compilationService.CompileAsync(inputPath, args.NoRestore);
if (diagnosticLogger.ErrorCount > 0)
{
// can't publish if we can't compile
return(1);
}
var stream = new MemoryStream();
compilationWriter.ToStream(compilation, stream);
stream.Position = 0;
await this.PublishModuleAsync(compilation.Configuration, moduleReference, stream);
return(0);
}
public async Task <int> RunAsync(BuildArguments args)
{
var inputPath = PathHelper.ResolvePath(args.InputFile);
if (invocationContext.EmitterSettings.EnableSymbolicNames)
{
logger.LogWarning(CliResources.SymbolicNamesDisclaimerMessage);
}
if (invocationContext.Features.ResourceTypedParamsAndOutputsEnabled)
{
logger.LogWarning(CliResources.ResourceTypesDisclaimerMessage);
}
if (!IsBicepFile(inputPath))
{
logger.LogError(CliResources.UnrecognizedFileExtensionMessage, inputPath);
return(1);
}
var compilation = await compilationService.CompileAsync(inputPath, args.NoRestore);
if (diagnosticLogger.ErrorCount < 1)
{
if (args.OutputToStdOut)
{
writer.ToStdout(compilation);
}
else
{
public async Task <int> RunAsync(GenerateParametersFileArguments args)
{
var inputPath = PathHelper.ResolvePath(args.InputFile);
if (invocationContext.EmitterSettings.EnableSymbolicNames)
{
logger.LogWarning(CliResources.SymbolicNamesDisclaimerMessage);
}
if (invocationContext.Features.ResourceTypedParamsAndOutputsEnabled)
{
logger.LogWarning(CliResources.ResourceTypesDisclaimerMessage);
}
if (!IsBicepFile(inputPath))
{
logger.LogError(CliResources.UnrecognizedFileExtensionMessage, inputPath);
return(1);
}
var compilation = await compilationService.CompileAsync(inputPath, args.NoRestore);
if (diagnosticLogger.ErrorCount < 1)
{
if (args.OutputToStdOut)
{
writer.ToStdout(compilation);
}
else
{
var outputPath = string.Empty;
if (!string.IsNullOrWhiteSpace(args.OutputDir))
{
outputPath = args.OutputDir;
}
else if (!string.IsNullOrWhiteSpace(args.OutputFile))
{
outputPath = args.OutputFile;
}
else
{
outputPath = inputPath;
}
outputPath = PathHelper.ResolveParametersFileOutputPath(outputPath);
writer.ToFile(compilation, outputPath);
}
}
// return non-zero exit code on errors
return(diagnosticLogger.ErrorCount > 0 ? 1 : 0);
}
public async Task <int> RunAsync(BuildArguments args)
{
var inputPath = PathHelper.ResolvePath(args.InputFile);
if (invocationContext.EmitterSettings.EnableSymbolicNames)
{
logger.LogWarning(CliResources.SymbolicNamesDisclaimerMessage);
}
var compilation = await compilationService.CompileAsync(inputPath, args.NoRestore);
if (diagnosticLogger.ErrorCount < 1)
{
if (args.OutputToStdOut)
{
writer.ToStdout(compilation);
}
else
{
public async Task <int> RunAsync(PublishArguments args)
{
var moduleReference = ValidateReference(args.TargetModuleReference);
var inputPath = PathHelper.ResolvePath(args.InputFile);
var compilation = await compilationService.CompileAsync(inputPath, args.NoRestore);
if (diagnosticLogger.ErrorCount > 0)
{
// can't publish if we can't compile
return(1);
}
var stream = new MemoryStream();
compilationWriter.ToStream(compilation, stream);
stream.Position = 0;
await this.moduleDispatcher.PublishModule(compilation.Configuration, moduleReference, stream);
return(0);
}
