public bool Compile(IReadOnlyCollection <AbstractFunctionDefinition> functionDefinitions,
Type backlinkType,
PropertyInfo backlinkPropertyInfo,
string newAssemblyNamespace,
IReadOnlyCollection <string> externalAssemblyLocations,
string outputBinaryFolder,
string assemblyName,
OpenApiOutputModel openApiOutputModel,
CompileTargetEnum compileTarget,
string outputAuthoredSourceFolder = null)
{
HandlebarsHelperRegistration.RegisterHelpers();
IReadOnlyCollection <SyntaxTree> syntaxTrees = CompileSource(functionDefinitions,
openApiOutputModel,
backlinkType,
backlinkPropertyInfo,
newAssemblyNamespace,
outputAuthoredSourceFolder);
bool isFSharpProject = functionDefinitions.Any(x => x.IsFunctionalFunction);
return(CompileAssembly(
syntaxTrees,
externalAssemblyLocations,
openApiOutputModel,
outputBinaryFolder,
assemblyName,
newAssemblyNamespace,
compileTarget,
isFSharpProject));
}
private List <SyntaxTree> CompileSource(IReadOnlyCollection <AbstractFunctionDefinition> functionDefinitions,
OpenApiOutputModel openApiOutputModel,
Type backlinkType,
PropertyInfo backlinkPropertyInfo,
string newAssemblyNamespace,
string outputAuthoredSourceFolder)
{
List <SyntaxTree> syntaxTrees = new List <SyntaxTree>();
DirectoryInfo directoryInfo = outputAuthoredSourceFolder != null ? new DirectoryInfo(outputAuthoredSourceFolder) : null;
if (directoryInfo != null && !directoryInfo.Exists)
{
directoryInfo = null;
}
foreach (AbstractFunctionDefinition functionDefinition in functionDefinitions)
{
string templateSource = _templateProvider.GetCSharpTemplate(functionDefinition);
AddSyntaxTreeFromHandlebarsTemplate(templateSource, functionDefinition.Name, functionDefinition, directoryInfo, syntaxTrees);
}
if (openApiOutputModel != null && openApiOutputModel.IsConfiguredForUserInterface)
{
string templateSource = _templateProvider.GetTemplate("swaggerui", "csharp");
AddSyntaxTreeFromHandlebarsTemplate(templateSource, "SwaggerUi", new
{
Namespace = newAssemblyNamespace
}, directoryInfo, syntaxTrees);
}
{
string templateSource = _templateProvider.GetTemplate("startup", "csharp");
AddSyntaxTreeFromHandlebarsTemplate(templateSource, "Startup", new
{
Namespace = newAssemblyNamespace
}, directoryInfo, syntaxTrees);
}
CreateLinkBack(functionDefinitions, backlinkType, backlinkPropertyInfo, newAssemblyNamespace, directoryInfo, syntaxTrees);
return(syntaxTrees);
}
public void Compile(IReadOnlyCollection <AbstractFunctionDefinition> functionDefinitions,
OpenApiOutputModel openApiOutputModel,
string outputBinaryFolder,
string outputNamespaceName)
{
HandlebarsHelperRegistration.RegisterHelpers();
foreach (AbstractFunctionDefinition functionDefinition in functionDefinitions)
{
string templateSource = _templateProvider.GetJsonTemplate(functionDefinition);
Func <object, string> template = Handlebars.Compile(templateSource);
functionDefinition.AssemblyName = $"{outputNamespaceName}.dll";
functionDefinition.FunctionClassTypeName = $"{functionDefinition.Namespace}.{functionDefinition.Name}";
string json = template(functionDefinition);
WriteFunctionTemplate(outputBinaryFolder, functionDefinition.Name, json);
if (functionDefinition is CosmosDbFunctionDefinition cosmosDbFunctionDefinition)
{
if (cosmosDbFunctionDefinition.TrackRemainingWork)
{
TimerFunctionDefinition cosmosMonitorDefinition = new TimerFunctionDefinition(functionDefinition.CommandType)
{
AssemblyName = cosmosDbFunctionDefinition.AssemblyName,
CommandDeserializerType = null,
CommandType = null,
CronExpression = cosmosDbFunctionDefinition.RemainingWorkCronExpression,
FunctionClassTypeName = $"{functionDefinition.Namespace}.Monitor{functionDefinition.Name}"
};
string timerTemplateSource = _templateProvider.GetJsonTemplate(cosmosMonitorDefinition);
Func <object, string> timerTemplate = Handlebars.Compile(timerTemplateSource);
string timerJson = timerTemplate(cosmosMonitorDefinition);
WriteFunctionTemplate(outputBinaryFolder, $"Monitor{functionDefinition.Name}", timerJson);
}
}
}
if (openApiOutputModel != null && openApiOutputModel.IsConfiguredForUserInterface)
{
string templateSource = _templateProvider.GetTemplate("swaggerui", "json");
Func <object, string> template = Handlebars.Compile(templateSource);
string json = template(new
{
AssemblyName = $"{outputNamespaceName}.dll",
Namespace = outputNamespaceName
});
WriteFunctionTemplate(outputBinaryFolder, "OpenApiProvider", json);
}
{
string templateSource = _templateProvider.GetTemplate("extensions", "json");
Func <object, string> template = Handlebars.Compile(templateSource);
string json = template(new
{
AssemblyName = $"{outputNamespaceName}",
Namespace = outputNamespaceName
});
WriteExtensionsTemplate(outputBinaryFolder, json);
}
}
private bool CompileAssembly(IReadOnlyCollection <SyntaxTree> syntaxTrees,
IReadOnlyCollection <string> externalAssemblyLocations,
OpenApiOutputModel openApiOutputModel,
string outputBinaryFolder,
string outputAssemblyName,
string assemblyNamespace,
CompileTargetEnum compileTarget,
bool isFSharpProject)
{
IReadOnlyCollection <string> locations = BuildCandidateReferenceList(externalAssemblyLocations, compileTarget, isFSharpProject);
const string manifestResourcePrefix = "FunctionMonkey.Compiler.references.netstandard2._0.";
// For each assembly we've found we need to check and see if it is already included in the output binary folder
// If it is then its referenced already by the function host and so we add a reference to that version.
List <string> resolvedLocations = ResolveLocationsWithExistingReferences(outputBinaryFolder, locations);
string[] manifestResoureNames = GetType().Assembly.GetManifestResourceNames()
.Where(x => x.StartsWith(manifestResourcePrefix))
.Select(x => x.Substring(manifestResourcePrefix.Length))
.ToArray();
List <PortableExecutableReference> references = BuildReferenceSet(resolvedLocations, manifestResoureNames, manifestResourcePrefix, compileTarget);
CSharpCompilation compilation = CSharpCompilation.Create(outputAssemblyName)
.WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(references)
.AddSyntaxTrees(syntaxTrees)
;
List <ResourceDescription> resources = null;
if (openApiOutputModel != null)
{
resources = new List <ResourceDescription>();
Debug.Assert(openApiOutputModel.OpenApiSpecification != null);
resources.Add(new ResourceDescription($"{assemblyNamespace}.OpenApi.{openApiOutputModel.OpenApiSpecification.Filename}",
() => new MemoryStream(Encoding.UTF8.GetBytes(openApiOutputModel.OpenApiSpecification.Content)), true));
if (openApiOutputModel.SwaggerUserInterface != null)
{
foreach (OpenApiFileReference fileReference in openApiOutputModel.SwaggerUserInterface)
{
OpenApiFileReference closureCapturedFileReference = fileReference;
resources.Add(new ResourceDescription($"{assemblyNamespace}.OpenApi.{closureCapturedFileReference.Filename}",
() => new MemoryStream(Encoding.UTF8.GetBytes(closureCapturedFileReference.Content)), true));
}
}
}
string outputFilename = Path.Combine(outputBinaryFolder, outputAssemblyName);
EmitResult compilationResult = compilation.Emit(outputFilename, manifestResources: resources);
if (!compilationResult.Success)
{
IEnumerable <Diagnostic> failures = compilationResult.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
foreach (Diagnostic diagnostic in failures)
{
_compilerLog.Error($"Error compiling function: {diagnostic.ToString()}");
}
}
return(compilationResult.Success);
}
public OpenApiOutputModel Compile(OpenApiConfiguration configuration, IReadOnlyCollection <AbstractFunctionDefinition> abstractFunctionDefinitions, string outputBinaryFolder)
{
string apiPrefix = GetApiPrefix(outputBinaryFolder);
if (!configuration.IsValid)
{
throw new ConfigurationException("Open API implementation is partially complete, a title and a version must be specified");
}
if (!configuration.IsOpenApiOutputEnabled)
{
return(null);
}
HttpFunctionDefinition[] functionDefinitions = abstractFunctionDefinitions.OfType <HttpFunctionDefinition>().ToArray();
if (functionDefinitions.Length == 0)
{
return(null);
}
OpenApiDocument openApiDocument = new OpenApiDocument
{
Info = new OpenApiInfo
{
Version = configuration.Version,
Title = configuration.Title
},
Servers = configuration.Servers?.Select(x => new OpenApiServer {
Url = x
}).ToArray(),
Paths = new OpenApiPaths(),
Components = new OpenApiComponents
{
Schemas = new Dictionary <string, OpenApiSchema>()
}
};
var compilerConfiguration = new OpenApiCompilerConfiguration(configuration);
SchemaReferenceRegistry registry = new SchemaReferenceRegistry(compilerConfiguration);
CreateTags(functionDefinitions, openApiDocument);
CreateSchemas(functionDefinitions, openApiDocument, registry);
CreateOperationsFromRoutes(functionDefinitions, openApiDocument, registry, apiPrefix, compilerConfiguration);
FilterDocument(compilerConfiguration, openApiDocument);
if (openApiDocument.Paths.Count == 0)
{
return(null);
}
string yaml = openApiDocument.Serialize(OpenApiSpecVersion.OpenApi3_0, OpenApiFormat.Yaml);
OpenApiOutputModel result = new OpenApiOutputModel
{
OpenApiSpecification = new OpenApiFileReference
{
Content = yaml,
Filename = "openapi.yaml"
}
};
if (!string.IsNullOrWhiteSpace(configuration.UserInterfaceRoute))
{
result.SwaggerUserInterface = CopySwaggerUserInterfaceFilesToWebFolder();
}
if (!string.IsNullOrWhiteSpace(configuration.OutputPath))
{
if (Directory.Exists(configuration.OutputPath))
{
string pathAndFilename = Path.Combine(configuration.OutputPath, "openapi.yaml");
if (File.Exists(pathAndFilename))
{
File.Delete(pathAndFilename);
}
File.WriteAllText(pathAndFilename, yaml, Encoding.UTF8);
}
}
return(result);
}
