public SecondChoiceDropdownRestStore(CategoryRepository categoryRepository,
ContentSearchHandler contentSearchHandler,
TemplateResolver templateResolver)
{
_categoryRepository = categoryRepository;
_contentSearchHandler = contentSearchHandler;
_templateResolver = templateResolver;
}
public void Resolve_MissingView_Exception()
{
TemplateResolver resolver = new TemplateResolver();
string path = resolver.Resolve("does_not_exist.html");
Assert.Fail();
}
public void Resolve_ExistingView_Found()
{
TemplateResolver resolver = new TemplateResolver();
string path = resolver.Resolve("index.html");
Assert.IsNotNull(path);
}
public CachingUrlResolver(RouteCollection routes,
IContentLoader contentLoader,
SiteDefinitionRepository siteDefinitionRepository,
TemplateResolver templateResolver,
IPermanentLinkMapper permanentLinkMapper,
IObjectInstanceCache cache)
: base(routes, contentLoader, siteDefinitionRepository, templateResolver, permanentLinkMapper)
{
_cache = cache;
}
public void TestPerformCoreTemplateQuery_InvalidChoiceValueInvalidatesMatch()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test.1x", groupIdentity: "foo.test.template", precedence: 100).WithTag("framework", "netcoreapp1.0", "netcoreapp1.1"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test.2x", groupIdentity: "foo.test.template", precedence: 200).WithTag("framework", "netcoreapp2.0"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("framework", "netcoreapp3.0");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(2, unambiguousGroup.Count);
Assert.Equal(2, matchResult.GetBestTemplateMatchList().Count);
Assert.Contains(unambiguousGroup[0].MatchDisposition, x => x.Kind == MatchKind.InvalidParameterValue);
Assert.Contains(unambiguousGroup[1].MatchDisposition, x => x.Kind == MatchKind.InvalidParameterValue);
}
private Task <CreationResultStatus> EnterTemplateManipulationFlowAsync()
{
if (_commandInput.IsListFlagSpecified || _commandInput.IsHelpFlagSpecified)
{
TemplateListResolutionResult listingTemplateResolutionResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
return(Task.FromResult(HelpForTemplateResolution.CoordinateHelpAndUsageDisplay(listingTemplateResolutionResult, EnvironmentSettings, _commandInput, _hostDataLoader, _telemetryLogger, _templateCreator, _defaultLanguage, showUsageHelp: _commandInput.IsHelpFlagSpecified)));
}
TemplateResolutionResult templateResolutionResult = TemplateResolver.GetTemplateResolutionResult(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
if (templateResolutionResult.ResolutionStatus == TemplateResolutionResult.Status.SingleMatch)
{
TemplateInvocationCoordinator invocationCoordinator = new TemplateInvocationCoordinator(_settingsLoader, _commandInput, _telemetryLogger, CommandName, _inputGetter, _callbacks);
return(invocationCoordinator.CoordinateInvocationOrAcquisitionAsync(templateResolutionResult.TemplateToInvoke));
}
else
{
return(Task.FromResult(HelpForTemplateResolution.CoordinateAmbiguousTemplateResolutionDisplay(templateResolutionResult, EnvironmentSettings, _commandInput, _defaultLanguage, _settingsLoader.InstallUnitDescriptorCache.Descriptors.Values)));
}
}
public async Task <CreationResultStatus> CoordinateInvocationOrAcquisitionAsync()
{
EnsureTemplateResolutionResult();
if (_templateToInvoke != null)
{
// invoke and then check for updates
CreationResultStatus creationResult = await InvokeTemplateAsync();
// check for updates on this template (pack)
await CheckForTemplateUpdateAsync();
return(creationResult);
}
else
{
TemplateListResolutionResult listingTemplateListResolutionResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
return(HelpForTemplateResolution.CoordinateHelpAndUsageDisplay(listingTemplateListResolutionResult, _environment, _commandInput, _hostDataLoader, _telemetryLogger, _templateCreator, _defaultLanguage, false));
}
}
public void TestPerformAllTemplatesInContextQuery()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("Template1", name: "Template1", identity: "Template1")
.WithTag("type", "project"));
templatesToSearch.Add(new MockTemplateInfo("Template2", name: "Template2", identity: "Template2")
.WithTag("type", "item"));
templatesToSearch.Add(new MockTemplateInfo("Template3", name: "Template3", identity: "Template3")
.WithTag("type", "myType"));
templatesToSearch.Add(new MockTemplateInfo("Template4", name: "Template4", identity: "Template4")
.WithTag("type", "project"));
templatesToSearch.Add(new MockTemplateInfo("Template5", name: "Template5", identity: "Template5")
.WithTag("type", "project"));
IHostSpecificDataLoader hostDataLoader = new MockHostSpecificDataLoader();
IReadOnlyCollection <ITemplateMatchInfo> projectTemplates = TemplateResolver.PerformAllTemplatesInContextQuery(templatesToSearch, hostDataLoader, "project");
Assert.Equal(3, projectTemplates.Count);
Assert.True(projectTemplates.Where(x => string.Equals(x.Info.Identity, "Template1", StringComparison.Ordinal)).Any());
Assert.True(projectTemplates.Where(x => string.Equals(x.Info.Identity, "Template4", StringComparison.Ordinal)).Any());
Assert.True(projectTemplates.Where(x => string.Equals(x.Info.Identity, "Template5", StringComparison.Ordinal)).Any());
IReadOnlyCollection <ITemplateMatchInfo> itemTemplates = TemplateResolver.PerformAllTemplatesInContextQuery(templatesToSearch, hostDataLoader, "item");
Assert.Equal(1, itemTemplates.Count);
Assert.True(itemTemplates.Where(x => string.Equals(x.Info.Identity, "Template2", StringComparison.Ordinal)).Any());
//Visual Studio only supports "project" and "item", so using other types is no longer allowed, therefore "other" handling is removed.
//support of match on custom type still remains
IReadOnlyCollection <ITemplateMatchInfo> otherTemplates = TemplateResolver.PerformAllTemplatesInContextQuery(templatesToSearch, hostDataLoader, "other");
Assert.Equal(0, otherTemplates.Count);
Assert.False(otherTemplates.Where(x => string.Equals(x.Info.Identity, "Template3", StringComparison.Ordinal)).Any());
IReadOnlyCollection <ITemplateMatchInfo> customTypeTemplates = TemplateResolver.PerformAllTemplatesInContextQuery(templatesToSearch, hostDataLoader, "myType");
Assert.Equal(1, customTypeTemplates.Count);
Assert.True(customTypeTemplates.Where(x => string.Equals(x.Info.Identity, "Template3", StringComparison.Ordinal)).Any());
}
private async Task <CreationResultStatus> EnterMaintenanceFlowAsync()
{
if (!TemplateResolver.ValidateRemainingParameters(_commandInput, out IReadOnlyList <string> invalidParams))
{
HelpForTemplateResolution.DisplayInvalidParameters(invalidParams);
if (_commandInput.IsHelpFlagSpecified)
{
// this code path doesn't go through the full help & usage stack, so needs it's own call to ShowUsageHelp().
HelpForTemplateResolution.ShowUsageHelp(_commandInput, _telemetryLogger);
}
else
{
Reporter.Error.WriteLine(string.Format(LocalizableStrings.RunHelpForInformationAboutAcceptedParameters, CommandName).Bold().Red());
}
return(CreationResultStatus.InvalidParamValues);
}
// No other cases specified, we've fallen through to "Optional usage help + List"
TemplateListResolutionResult templateResolutionResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(
await _settingsLoader.GetTemplatesAsync(default).ConfigureAwait(false),
public void GivenOneInvokableTemplateWithNonDefaultLanguage_ItIsChosen()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test_1", groupIdentity: "foo.test.template", precedence: 100)
.WithTag("language", "F#"));
INewCommandInput userInputs = new MockNewCommandInput("foo");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
// make sure there's an unambiguous group, otherwise the singular match check is meaningless
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal(1, matchResult.GetBestTemplateMatchList().Count);
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo singularInvokableMatch, out Status resultStatus));
Assert.Equal(Status.SingleMatch, resultStatus);
Assert.Equal("foo.test_1", singularInvokableMatch.Info.Identity);
}
public async Task ShouldResolveS3UrlLocationAsS3(string url, string resolvedUrl)
{
var mockClientFactory = new Mock <IAwsClientFactory>();
var mockS3Util = new Mock <IS3Util>();
mockS3Util.Setup(s3 => s3.GetS3ObjectContent(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(this.fixture.TestStackJsonString);
var mockContext = new Mock <ICloudFormationContext>();
mockContext.Setup(c => c.S3Util).Returns(mockS3Util.Object);
var resolver = new TemplateResolver(mockClientFactory.Object, mockContext.Object, StackName, false, false);
await resolver.ResolveFileAsync(url);
resolver.Source.Should().Be(InputFileSource.S3);
resolver.ArtifactUrl.Should().Be(resolvedUrl);
resolver.FileContent.Should().NotBeNullOrEmpty();
resolver.ArtifactContent.Should().BeNull();
}
public void TestGetTemplateResolutionResult_AuthorMatch(string templateAuthor, string commandAuthor, bool matchExpected)
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(
new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test", author: templateAuthor)
.WithTag("language", "L1")
.WithTag("type", "project")
.WithClassifications("Common", "Test")
.WithBaselineInfo("app", "standard"));
INewCommandInput userInputs = new MockNewCommandInput("console").WithListOption().WithCommandOption("--author", commandAuthor);
TemplateListResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
if (matchExpected)
{
Assert.True(matchResult.HasExactMatches);
Assert.Equal(1, matchResult.ExactMatchedTemplatesGrouped.Count);
Assert.Equal(1, matchResult.ExactMatchedTemplates.Count);
Assert.False(matchResult.HasPartialMatches);
Assert.Equal(0, matchResult.PartiallyMatchedTemplates.Count);
Assert.Equal(0, matchResult.PartiallyMatchedTemplatesGrouped.Count);
Assert.False(matchResult.HasAuthorMismatch);
}
else
{
Assert.False(matchResult.HasExactMatches);
Assert.Equal(0, matchResult.ExactMatchedTemplatesGrouped.Count);
Assert.Equal(0, matchResult.ExactMatchedTemplates.Count);
Assert.True(matchResult.HasPartialMatches);
Assert.Equal(1, matchResult.PartiallyMatchedTemplates.Count);
Assert.Equal(1, matchResult.PartiallyMatchedTemplatesGrouped.Count);
Assert.True(matchResult.HasAuthorMismatch);
}
Assert.False(matchResult.HasLanguageMismatch);
Assert.False(matchResult.HasContextMismatch);
Assert.False(matchResult.HasBaselineMismatch);
}
public void TestGetTemplateResolutionResult_OtherParameterMatch_Text()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(
new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test1")
.WithTag("language", "L1")
.WithTag("type", "project")
.WithParameters("langVersion")
.WithBaselineInfo("app", "standard"));
templatesToSearch.Add(
new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T2", groupIdentity: "Console.App.Test2")
.WithTag("language", "L2")
.WithTag("type", "project")
.WithParameters("test")
.WithBaselineInfo("app", "standard"));
templatesToSearch.Add(
new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T3", groupIdentity: "Console.App.Test3")
.WithTag("language", "L3")
.WithTag("type", "project")
.WithBaselineInfo("app", "standard"));
INewCommandInput userInputs = new MockNewCommandInput("c").WithHelpOption().WithTemplateOption("langVersion");
TemplateListResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.True(matchResult.HasExactMatches);
Assert.Equal(1, matchResult.ExactMatchedTemplateGroups.Count);
Assert.Equal(1, matchResult.ExactMatchedTemplates.Count);
Assert.False(matchResult.HasLanguageMismatch);
Assert.False(matchResult.HasContextMismatch);
Assert.False(matchResult.HasBaselineMismatch);
Assert.True(matchResult.HasUnambiguousTemplateGroup);
Assert.Equal(1, matchResult.UnambiguousTemplateGroup.Count);
HelpForTemplateResolution.GetParametersInvalidForTemplatesInList(matchResult.ExactMatchedTemplates, out IReadOnlyList <string> invalidForAllTemplates, out IReadOnlyList <string> invalidForSomeTemplates);
Assert.Equal(0, invalidForSomeTemplates.Count);
Assert.Equal(0, invalidForAllTemplates.Count);
}
public static CreationResultStatus HandleParseError(INewCommandInput commandInput, ITelemetryLogger telemetryLogger)
{
TemplateResolver.ValidateRemainingParameters(commandInput, out IReadOnlyList <string> invalidParams);
DisplayInvalidParameters(invalidParams);
// TODO: get a meaningful error message from the parser
if (commandInput.IsHelpFlagSpecified)
{
// this code path doesn't go through the full help & usage stack, so needs it's own call to ShowUsageHelp().
ShowUsageHelp(commandInput, telemetryLogger);
}
else if (invalidParams.Count > 0)
{
Reporter.Error.WriteLine(string.Format(LocalizableStrings.RunHelpForInformationAboutAcceptedParameters, commandInput.CommandName).Bold().Red());
}
if (commandInput.HasColumnsParseError)
{
Reporter.Error.WriteLine(commandInput.ColumnsParseError.Bold().Red());
}
return(CreationResultStatus.InvalidParamValues);
}
public void TestGetTemplateResolutionResult_TemplateWithoutTypeShouldNotBeMatchedForContextFilter()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(
new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test")
.WithClassifications("Common", "Test"));
INewCommandInput userInputs = new MockNewCommandInput("Common", type: "item").WithListOption();
TemplateListResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.False(matchResult.HasExactMatches);
Assert.Equal(0, matchResult.ExactMatchedTemplatesGrouped.Count);
Assert.Equal(0, matchResult.ExactMatchedTemplates.Count);
Assert.True(matchResult.HasPartialMatches);
Assert.Equal(1, matchResult.PartiallyMatchedTemplates.Count);
Assert.Equal(1, matchResult.PartiallyMatchedTemplatesGrouped.Count);
Assert.False(matchResult.HasLanguageMismatch);
Assert.True(matchResult.HasContextMismatch);
Assert.False(matchResult.HasBaselineMismatch);
}
public FoundationSearchProvider(
LocalizationService localizationService,
ISiteDefinitionResolver siteDefinitionResolver,
IContentTypeRepository <ContentType> contentTypeRepository,
EditUrlResolver editUrlResolver,
ServiceAccessor <SiteDefinition> currentSiteDefinition,
LanguageResolver languageResolver,
UrlResolver urlResolver,
TemplateResolver templateResolver,
UIDescriptorRegistry uiDescriptorRegistry,
Mediachase.Commerce.Catalog.ReferenceConverter referenceConverter,
ServiceAccessor <SearchManager> searchManagerAccessor,
IContentLoader contentLoader,
IModuleResourceResolver moduleResourceResolver,
ServiceAccessor <SiteContext> siteContextAccessor,
IClient client) :
base(localizationService,
siteDefinitionResolver,
contentTypeRepository,
editUrlResolver,
currentSiteDefinition,
languageResolver,
urlResolver,
templateResolver,
uiDescriptorRegistry)
{
_languageResolver = languageResolver;
_localizationService = localizationService;
_referenceConverter = referenceConverter;
_searchManagerAccessor = searchManagerAccessor;
_contentLoader = contentLoader;
_siteContextAcessor = siteContextAccessor;
EditPath = (contentData, contentLink, languageName) =>
{
var catalogPath = moduleResourceResolver.ResolvePath("Commerce", "Catalog");
return($"{catalogPath}#context=epi.cms.contentdata:///{contentLink}");
};
_client = client;
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
if (variablesFile != null && !File.Exists(variablesFile))
{
throw new CommandException("Could not find variables file: " + variablesFile);
}
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariableFiles, sensitiveVariablesPassword);
variables.Set(SpecialVariables.OriginalPackageDirectoryPath, Environment.CurrentDirectory);
var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables)));
var fileSystem = new WindowsPhysicalFileSystem();
var filesInPackage = !string.IsNullOrWhiteSpace(packageFile);
var templateResolver = new TemplateResolver(fileSystem);
var templateService = new TemplateService(fileSystem, templateResolver, new TemplateReplacement(templateResolver));
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(new GenericPackageExtractorFactory().createStandardGenericPackageExtractor(), fileSystem),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new DeployAzureResourceGroupConvention(templateFile, templateParameterFile, filesInPackage, templateService, new ResourceGroupTemplateNormalizer()),
new PackagedScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
return(0);
}
public void TestGetTemplateResolutionResult_MatchByTagsIgnoredForHelp()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(
new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test1")
.WithTag("language", "L1")
.WithTag("type", "project")
.WithClassifications("Common", "Test")
.WithBaselineInfo("app", "standard"));
INewCommandInput userInputs = new MockNewCommandInput("Common").WithHelpOption();
TemplateListResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.False(matchResult.HasExactMatches);
Assert.False(matchResult.HasPartialMatches);
Assert.Equal(0, matchResult.ExactMatchedTemplateGroups.Count);
Assert.Equal(0, matchResult.ExactMatchedTemplates.Count);
Assert.False(matchResult.HasLanguageMismatch);
Assert.False(matchResult.HasTypeMismatch);
Assert.False(matchResult.HasBaselineMismatch);
}
public void MultipleTemplatesInGroupHavingAmbiguousParamMatchOnSameParamIsAmbiguous()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test_1", groupIdentity: "foo.test.template", precedence: 100)
.WithTag("MyChoice", "value_1", "value_2"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test_2", groupIdentity: "foo.test.template", precedence: 200)
.WithTag("MyChoice", "value_3", "value_4"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("MyChoice", "value_");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
// make sure there's an unambiguous group, otherwise the singular match check is meaningless
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(2, unambiguousGroup.Count);
Assert.Equal(2, matchResult.GetBestTemplateMatchList().Count);
Assert.False(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo singularInvokableMatch, out Status resultStatus));
Assert.Equal(Status.NoMatch, resultStatus);
Assert.Null(singularInvokableMatch);
}
public void AllTemplatesInGroupUseAllShortNamesForResolution()
{
IReadOnlyList <string> shortNamesForGroup = new List <string>()
{
"aaa", "bbb", "ccc", "ddd", "eee", "fff"
};
foreach (string testShortName in shortNamesForGroup)
{
INewCommandInput userInputs = new MockNewCommandInput(testShortName);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), userInputs, "C#");
matchResult.TryGetCoreMatchedTemplatesWithDisposition(x => x.IsMatch, out IReadOnlyList <ITemplateMatchInfo> matchedTemplateList);
Assert.Equal(3, matchedTemplateList.Count);
foreach (ITemplateMatchInfo templateMatchInfo in matchedTemplateList)
{
Assert.Equal("MultiName.Test", templateMatchInfo.Info.GroupIdentity);
Assert.Equal(1, templateMatchInfo.MatchDisposition.Count);
Assert.True(templateMatchInfo.MatchDisposition[0].Location == MatchLocation.ShortName && templateMatchInfo.MatchDisposition[0].Kind == MatchKind.Exact);
}
}
}
public PropertyRendererInterceptor(PropertyRenderer defaultRenderer, IContextModeResolver contextModeResolver, IHtmlCache htmlCache, TemplateResolver templateResolver, CachingViewEnginesWrapper viewResolver)
{
_defaultRenderer = defaultRenderer;
_contextModeResolver = contextModeResolver;
_htmlCache = htmlCache;
_templateResolver = templateResolver;
_viewResolver = viewResolver;
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomContentAreaRenderer"/> class.
/// </summary>
/// <param name="contentRenderer"></param>
/// <param name="templateResolver"></param>
/// <param name="attributeAssembler"></param>
/// <param name="contentRepository"></param>
/// <param name="displayOptions"></param>
public CustomContentAreaRenderer(IContentRenderer contentRenderer, TemplateResolver templateResolver, ContentFragmentAttributeAssembler attributeAssembler, IContentRepository contentRepository, DisplayOptions displayOptions)
: base(contentRenderer, templateResolver, attributeAssembler, contentRepository, displayOptions)
{
}
public CategoriesSearchProvider(LocalizationService localizationService, ISiteDefinitionResolver siteDefinitionResolver, IContentTypeRepository <ContentType> contentTypeRepository, EditUrlResolver editUrlResolver, ServiceAccessor <SiteDefinition> currentSiteDefinition, IContentRepository contentRepository, ILanguageBranchRepository languageBranchRepository, SearchHandler searchHandler, ContentSearchHandler contentSearchHandler, SearchIndexConfig searchIndexConfig, UIDescriptorRegistry uiDescriptorRegistry, LanguageResolver languageResolver, UrlResolver urlResolver, TemplateResolver templateResolver, IEnumerable <IContentRepositoryDescriptor> contentRepositoryDescriptors) : base(localizationService, siteDefinitionResolver, contentTypeRepository, editUrlResolver, currentSiteDefinition, contentRepository, languageBranchRepository, searchHandler, contentSearchHandler, searchIndexConfig, uiDescriptorRegistry, languageResolver, urlResolver, templateResolver)
{
_localizationService = localizationService;
_contentRepositoryDescriptors = contentRepositoryDescriptors;
}
/// <summary>
/// Initializes a new instance of the <see cref="AlloyContentAreaRenderer"/> class.
/// </summary>
/// <param name="contentRenderer">The content renderer.</param>
/// <param name="templateResolver">The template resolver.</param>
/// <param name="attributeAssembler">The attribute assembler.</param>
public AlloyContentAreaRenderer(IContentRenderer contentRenderer, TemplateResolver templateResolver, ContentFragmentAttributeAssembler attributeAssembler)
: base(contentRenderer, templateResolver, attributeAssembler)
{
}
public void Invoke(CompositionContainer container)
{
var traceListener = new ConsolidatedConsoleTraceListener(
new Dictionary <string, string>
{
{
"LostDoc.Core.Template",
"Template"
},
{
"LostDoc.Core.Bundle",
"Bundle"
},
{
"LostDoc.Core.Template.AssetResolver",
"Resolve"
}
});
TraceSources.TemplateSource.Listeners.Add(traceListener);
TraceSources.AssetResolverSource.Listeners.Add(traceListener);
try
{
if (this.Quiet.IsPresent)
{
const SourceLevels quietLevel = SourceLevels.Error | SourceLevels.Warning | SourceLevels.Critical;
TraceSources.TemplateSource.Switch.Level = quietLevel;
TraceSources.AssetResolverSource.Switch.Level = quietLevel;
TraceSources.BundleSource.Listeners.Add(traceListener);
}
else if (this.Verbose.IsPresent)
{
const SourceLevels verboseLevel = SourceLevels.All;
TraceSources.TemplateSource.Switch.Level = verboseLevel;
TraceSources.AssetResolverSource.Switch.Level = verboseLevel;
TraceSources.BundleSource.Listeners.Add(traceListener);
}
else
{
const SourceLevels normalLevel = SourceLevels.Information | SourceLevels.Warning | SourceLevels.Error | SourceLevels.ActivityTracing;
TraceSources.TemplateSource.Switch.Level = normalLevel;
TraceSources.AssetResolverSource.Switch.Level = normalLevel;
}
LinkedList <FileInfo> includedFiles = new LinkedList <FileInfo>();
if (File.Exists(this.Path))
{
includedFiles.AddLast(new FileInfo(this.Path));
}
else if (Directory.Exists(this.Path))
{
Directory.GetFiles(this.Path, "*.ldoc", SearchOption.AllDirectories)
.Aggregate(includedFiles,
(l, f) => l.AddLast(new FileInfo(f)).List);
}
else
{
throw new FileNotFoundException(System.IO.Path.GetFullPath(this.Path));
}
Bundle bundle = new Bundle(this.IgnoreVersionComponent);
TraceSources.TemplateSource.TraceInformation("Merging LostDoc files into bundle.");
foreach (FileInfo file in includedFiles)
{
TraceSources.TemplateSource.TraceEvent(TraceEventType.Information, 0, "Source: {0}", file.Name);
XDocument fileDoc = XDocument.Load(file.FullName);
bundle.Add(fileDoc);
}
var lazyProviders = container.GetExports <IFileProvider>(ContractNames.TemplateProvider);
var realProviders = lazyProviders.Select(lazy => lazy.Value);
TemplateResolver templateResolver = new TemplateResolver(realProviders.ToArray());
Template template = new Template(container);
template.Load(templateResolver, this.Template);
string outputDir = this.Output
?? (Directory.Exists(this.Path)
? this.Path
: System.IO.Path.GetDirectoryName(this.Path));
AssetRedirectCollection assetRedirects;
XDocument mergedDoc = bundle.Merge(out assetRedirects);
var templateData = new TemplateData(mergedDoc)
{
AssetRedirects = assetRedirects,
OverwriteExistingFiles = this.Force.IsPresent,
IgnoredVersionComponent = this.IgnoreVersionComponent,
Arguments = this.Arguments,
OutputFileProvider = new ScopedFileProvider(new DirectoryFileProvider(), outputDir)
};
template.Generate(templateData);
}
finally
{
TraceSources.TemplateSource.Listeners.Remove(traceListener);
TraceSources.AssetResolverSource.Listeners.Remove(traceListener);
}
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var filesInPackage = !string.IsNullOrWhiteSpace(pathToPackage);
var environment = AwsEnvironmentGeneration.Create(log, variables).GetAwaiter().GetResult();
var templateResolver = new TemplateResolver(fileSystem);
IAmazonCloudFormation ClientFactory() => ClientHelpers.CreateCloudFormationClient(environment);
StackArn StackProvider(RunningDeployment x) => new StackArn(stackName);
ChangeSetArn ChangesetProvider(RunningDeployment x) => new ChangeSetArn(x.Variables[AwsSpecialVariables.CloudFormation.Changesets.Arn]);
string RoleArnProvider(RunningDeployment x) => x.Variables[AwsSpecialVariables.CloudFormation.RoleArn];
var iamCapabilities = JsonConvert.DeserializeObject <List <string> >(variables.Get(AwsSpecialVariables.IamCapabilities, "[]"));
var tags = JsonConvert.DeserializeObject <List <KeyValuePair <string, string> > >(variables.Get(AwsSpecialVariables.CloudFormation.Tags, "[]"));
var deployment = new RunningDeployment(pathToPackage, variables);
ICloudFormationRequestBuilder TemplateFactory() => string.IsNullOrWhiteSpace(templateS3Url)
? CloudFormationTemplate.Create(templateResolver,
templateFile,
templateParameterFile,
filesInPackage,
fileSystem,
variables,
stackName,
iamCapabilities,
disableRollback,
RoleArnProvider(deployment),
tags,
StackProvider(deployment),
ClientFactory)
: CloudFormationS3Template.Create(templateS3Url,
templateParameterS3Url,
fileSystem,
variables,
log,
stackName,
iamCapabilities,
disableRollback,
RoleArnProvider(deployment),
tags,
StackProvider(deployment),
ClientFactory);
var stackEventLogger = new StackEventLogger(log);
var conventions = new List <IConvention>
{
new LogAwsUserInfoConvention(environment),
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
new StructuredConfigurationVariablesConvention(new StructuredConfigurationVariablesBehaviour(structuredConfigVariablesService)),
//Create or Update the stack using changesets
new AggregateInstallationConvention(
new GenerateCloudFormationChangesetNameConvention(log),
new CreateCloudFormationChangeSetConvention(ClientFactory,
stackEventLogger,
StackProvider,
TemplateFactory),
new DescribeCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider),
new ExecuteCloudFormationChangeSetConvention(ClientFactory,
stackEventLogger,
StackProvider,
ChangesetProvider,
waitForComplete)
.When(ImmediateChangesetExecution),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider)
.When(ImmediateChangesetExecution)
).When(ChangesetsEnabled),
//Create or update stack using a template (no changesets)
new AggregateInstallationConvention(
new DeployAwsCloudFormationConvention(
ClientFactory,
TemplateFactory,
stackEventLogger,
StackProvider,
RoleArnProvider,
waitForComplete,
stackName,
environment),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider)
)
.When(ChangesetsDisabled)
};
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
conventionRunner.RunConventions();
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
if (variablesFile != null && !File.Exists(variablesFile))
{
throw new CommandException("Could not find variables file: " + variablesFile);
}
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile,
sensitiveVariablesPassword);
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var filesInPackage = !string.IsNullOrWhiteSpace(packageFile);
var environment = new AwsEnvironmentGeneration(variables);
var templateResolver = new TemplateResolver(fileSystem);
IAmazonCloudFormation ClientFactory() => ClientHelpers.CreateCloudFormationClient(environment);
StackArn StackProvider(RunningDeployment x) => new StackArn(stackName);
ChangeSetArn ChangesetProvider(RunningDeployment x) => new ChangeSetArn(x.Variables[AwsSpecialVariables.CloudFormation.Changesets.Arn]);
string RoleArnProvider(RunningDeployment x) => x.Variables[AwsSpecialVariables.CloudFormation.RoleArn];
CloudFormationTemplate TemplateFactory()
{
var resolvedTemplate = templateResolver.Resolve(templateFile, filesInPackage, variables);
var resolvedParameters = templateResolver.MaybeResolve(templateParameterFile, filesInPackage, variables);
if (templateParameterFile != null && !resolvedParameters.Some())
{
throw new CommandException("Could not find template parameters file: " + templateParameterFile);
}
var parameters = CloudFormationParametersFile.Create(resolvedParameters, fileSystem, variables);
return(CloudFormationTemplate.Create(resolvedTemplate, parameters, fileSystem, variables));
}
var stackEventLogger = new StackEventLogger(new LogWrapper());
var conventions = new List <IConvention>
{
new LogAwsUserInfoConvention(environment),
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(new GenericPackageExtractorFactory().createStandardGenericPackageExtractor(), fileSystem),
//Create or Update the stack using changesets
new AggregateInstallationConvention(
new GenerateCloudFormationChangesetNameConvention(),
new CreateCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, RoleArnProvider, TemplateFactory, iamCapabilities),
new DescribeCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider),
new ExecuteCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider, waitForComplete)
.When(ImmediateChangesetExecution),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider, () => TemplateFactory().HasOutputs)
.When(ImmediateChangesetExecution)
).When(ChangesetsEnabled),
//Create or update stack using a template (no changesets)
new AggregateInstallationConvention(
new DeployAwsCloudFormationConvention(
ClientFactory,
TemplateFactory,
stackEventLogger,
StackProvider,
RoleArnProvider,
waitForComplete,
stackName,
iamCapabilities,
disableRollback,
environment),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider, () => TemplateFactory().HasOutputs)
)
.When(ChangesetsDisabled)
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
return(0);
}
/// <summary>
/// Initializes a new instance of the <see cref="AlloyContentAreaRenderer"/> class.
/// </summary>
/// <param name="contentRenderer">The content renderer.</param>
/// <param name="templateResolver">The template resolver.</param>
/// <param name="attributeAssembler">The attribute assembler.</param>
public AlloyContentAreaRenderer(IContentRenderer contentRenderer, TemplateResolver templateResolver, ContentFragmentAttributeAssembler attributeAssembler)
: base(contentRenderer, templateResolver, attributeAssembler)
{
}
public PreviewController(IContentLoader contentLoader, TemplateResolver templateResolver, DisplayOptions displayOptions)
{
_contentLoader = contentLoader;
_templateResolver = templateResolver;
_displayOptions = displayOptions;
}
protected async void LoadTemplate(EmailTemplates template, Dictionary <string, string> keyValuePairs)
{
await TemplateResolver.LoadTemplateAsync(template, keyValuePairs).ConfigureAwait(false);
}
internal static TemplateUsageInformation?GetTemplateUsageInformation(ITemplateInfo templateInfo, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, TemplateCreator templateCreator)
{
IParameterSet allParams;
IReadOnlyList <string> userParamsWithInvalidValues;
HashSet <string> userParamsWithDefaultValues;
bool hasPostActionScriptRunner;
ITemplate?template = environmentSettings.SettingsLoader.LoadTemplate(templateInfo, commandInput.BaselineName);
if (template == null)
{
return(null);
}
TemplateResolver.ParseTemplateArgs(templateInfo, hostDataLoader, commandInput);
allParams = templateCreator.SetupDefaultParamValuesFromTemplateAndHost(template, template.DefaultName ?? "testName", out IReadOnlyList <string> defaultParamsWithInvalidValues);
templateCreator.ResolveUserParameters(template, allParams, commandInput.InputTemplateParams, out userParamsWithInvalidValues);
hasPostActionScriptRunner = CheckIfTemplateHasScriptRunningPostActions(template, environmentSettings, commandInput, templateCreator);
templateCreator.ReleaseMountPoints(template);
List <InvalidParameterInfo> invalidParameters = new List <InvalidParameterInfo>();
if (userParamsWithInvalidValues.Any())
{
// Lookup the input param formats - userParamsWithInvalidValues has canonical.
foreach (string canonical in userParamsWithInvalidValues)
{
commandInput.InputTemplateParams.TryGetValue(canonical, out string specifiedValue);
string inputFormat = commandInput.TemplateParamInputFormat(canonical);
InvalidParameterInfo invalidParam = new InvalidParameterInfo(InvalidParameterInfo.Kind.InvalidParameterValue, inputFormat, specifiedValue, canonical);
invalidParameters.Add(invalidParam);
}
}
if (templateCreator.AnyParametersWithInvalidDefaultsUnresolved(defaultParamsWithInvalidValues, userParamsWithInvalidValues, commandInput.InputTemplateParams, out IReadOnlyList <string> defaultsWithUnresolvedInvalidValues))
{
IParameterSet templateParams = template.Generator.GetParametersForTemplate(environmentSettings, template);
foreach (string defaultParamName in defaultsWithUnresolvedInvalidValues)
{
ITemplateParameter param = templateParams.ParameterDefinitions.FirstOrDefault(x => string.Equals(x.Name, defaultParamName, StringComparison.Ordinal));
if (param != null)
{
// Get the best input format available.
IReadOnlyList <string> inputVariants = commandInput.VariantsForCanonical(param.Name);
string displayName = inputVariants.FirstOrDefault(x => x.Contains(param.Name))
?? inputVariants.Aggregate("", (max, cur) => max.Length > cur.Length ? max : cur)
?? param.Name;
InvalidParameterInfo invalidParam = new InvalidParameterInfo(InvalidParameterInfo.Kind.InvalidDefaultValue, displayName, param.DefaultValue, displayName);
invalidParameters.Add(invalidParam);
}
}
}
// get all the flags
// get all the user input params that have the default value
Dictionary <string, IReadOnlyList <string> > inputFlagVariants = new Dictionary <string, IReadOnlyList <string> >();
userParamsWithDefaultValues = new HashSet <string>();
foreach (string paramName in allParams.ParameterDefinitions.Select(x => x.Name))
{
inputFlagVariants[paramName] = commandInput.VariantsForCanonical(paramName);
if (commandInput.TemplateParamHasValue(paramName) && string.IsNullOrEmpty(commandInput.TemplateParamValue(paramName)))
{
userParamsWithDefaultValues.Add(paramName);
}
}
IReadOnlyDictionary <string, IReadOnlyList <string> > variantsForCanonicals = inputFlagVariants;
return(new TemplateUsageInformation
{
InvalidParameters = invalidParameters,
AllParameters = allParams,
UserParametersWithInvalidValues = userParamsWithInvalidValues,
UserParametersWithDefaultValues = userParamsWithDefaultValues,
VariantsForCanonicals = variantsForCanonicals,
HasPostActionScriptRunner = hasPostActionScriptRunner
});
}
// Attempts to invoke the template.
// Warning: The _commandInput cannot be assumed to be in a state that is parsed for the template being invoked.
// So be sure to only get template-agnostic information from it. Anything specific to the template must be gotten from the ITemplateMatchInfo
// Or do a reparse if necessary (currently occurs in one error case).
private async Task <CreationResultStatus> CreateTemplateAsync(ITemplateMatchInfo templateMatchDetails)
{
ITemplateInfo template = templateMatchDetails.Info;
char[] invalidChars = Path.GetInvalidFileNameChars();
if (_commandInput?.Name != null && _commandInput.Name.IndexOfAny(invalidChars) > -1)
{
string printableChars = string.Join(", ", invalidChars.Where(x => !char.IsControl(x)).Select(x => $"'{x}'"));
string nonPrintableChars = string.Join(", ", invalidChars.Where(char.IsControl).Select(x => $"char({(int)x})"));
Reporter.Error.WriteLine(string.Format(LocalizableStrings.InvalidNameParameter, printableChars, nonPrintableChars).Bold().Red());
return(CreationResultStatus.CreateFailed);
}
string fallbackName = new DirectoryInfo(
!string.IsNullOrWhiteSpace(_commandInput.OutputPath)
? _commandInput.OutputPath
: Directory.GetCurrentDirectory())
.Name;
if (string.IsNullOrEmpty(fallbackName) || string.Equals(fallbackName, "/", StringComparison.Ordinal))
{ // DirectoryInfo("/").Name on *nix returns "/", as opposed to null or "".
fallbackName = null;
}
// Name returns <disk letter>:\ for root disk folder on Windows - replace invalid chars
else if (fallbackName.IndexOfAny(invalidChars) > -1)
{
Regex pattern = new Regex($"[{Regex.Escape(new string(invalidChars))}]");
fallbackName = pattern.Replace(fallbackName, "");
if (string.IsNullOrWhiteSpace(fallbackName))
{
fallbackName = null;
}
}
TemplateCreationResult instantiateResult;
try
{
instantiateResult = await _templateCreator.InstantiateAsync(template, _commandInput.Name, fallbackName, _commandInput.OutputPath,
templateMatchDetails.GetValidTemplateParameters(), _commandInput.SkipUpdateCheck, _commandInput.IsForceFlagSpecified,
_commandInput.BaselineName, _commandInput.IsDryRun)
.ConfigureAwait(false);
}
catch (ContentGenerationException cx)
{
Reporter.Error.WriteLine(cx.Message.Bold().Red());
if (cx.InnerException != null)
{
Reporter.Error.WriteLine(cx.InnerException.Message.Bold().Red());
}
return(CreationResultStatus.CreateFailed);
}
catch (TemplateAuthoringException tae)
{
Reporter.Error.WriteLine(tae.Message.Bold().Red());
return(CreationResultStatus.CreateFailed);
}
string resultTemplateName = string.IsNullOrEmpty(instantiateResult.TemplateFullName) ? _commandInput.TemplateName : instantiateResult.TemplateFullName;
switch (instantiateResult.Status)
{
case CreationResultStatus.Success:
if (!_commandInput.IsDryRun)
{
Reporter.Output.WriteLine(string.Format(LocalizableStrings.CreateSuccessful, resultTemplateName));
}
else
{
Reporter.Output.WriteLine(LocalizableStrings.FileActionsWouldHaveBeenTaken);
foreach (IFileChange change in instantiateResult.CreationEffects.FileChanges)
{
Reporter.Output.WriteLine($" {change.ChangeKind}: {change.TargetRelativePath}");
}
}
if (!string.IsNullOrEmpty(template.ThirdPartyNotices))
{
Reporter.Output.WriteLine(string.Format(LocalizableStrings.ThirdPartyNotices, template.ThirdPartyNotices));
}
HandlePostActions(instantiateResult);
break;
case CreationResultStatus.CreateFailed:
Reporter.Error.WriteLine(string.Format(LocalizableStrings.CreateFailed, resultTemplateName, instantiateResult.Message).Bold().Red());
break;
case CreationResultStatus.MissingMandatoryParam:
if (string.Equals(instantiateResult.Message, "--name", StringComparison.Ordinal))
{
Reporter.Error.WriteLine(string.Format(LocalizableStrings.MissingRequiredParameter, instantiateResult.Message, resultTemplateName).Bold().Red());
}
else
{
// TODO: rework to avoid having to reparse.
// The canonical info could be in the ITemplateMatchInfo, but currently isn't.
TemplateResolver.ParseTemplateArgs(template, _hostDataLoader, _commandInput);
IReadOnlyList <string> missingParamNamesCanonical = instantiateResult.Message.Split(new[] { ',' })
.Select(x => _commandInput.VariantsForCanonical(x.Trim())
.DefaultIfEmpty(x.Trim()).First())
.ToList();
string fixedMessage = string.Join(", ", missingParamNamesCanonical);
Reporter.Error.WriteLine(string.Format(LocalizableStrings.MissingRequiredParameter, fixedMessage, resultTemplateName).Bold().Red());
}
break;
case CreationResultStatus.OperationNotSpecified:
break;
case CreationResultStatus.NotFound:
Reporter.Error.WriteLine(string.Format(LocalizableStrings.MissingTemplateContentDetected, _commandName).Bold().Red());
break;
case CreationResultStatus.InvalidParamValues:
TemplateUsageInformation?usageInformation = TemplateUsageHelp.GetTemplateUsageInformation(template, _environment, _commandInput, _hostDataLoader, _templateCreator);
if (usageInformation != null)
{
string invalidParamsError = InvalidParameterInfo.InvalidParameterListToString(usageInformation.Value.InvalidParameters);
Reporter.Error.WriteLine(invalidParamsError.Bold().Red());
Reporter.Error.WriteLine(string.Format(LocalizableStrings.RunHelpForInformationAboutAcceptedParameters, $"{_commandName} {_commandInput.TemplateName}").Bold().Red());
}
else
{
Reporter.Error.WriteLine(string.Format(LocalizableStrings.MissingTemplateContentDetected, _commandName).Bold().Red());
return(CreationResultStatus.NotFound);
}
break;
default:
break;
}
return(instantiateResult.Status);
}
public PreviewController(DisplayOptions displayOptions, TemplateResolver templateResolver, IEpiServerDependencies epiDependencies)
{
this.displayOptions = displayOptions;
this.templateResolver = templateResolver;
this.epiDependencies = epiDependencies;
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var filesInPackage = !string.IsNullOrWhiteSpace(pathToPackage);
var environment = AwsEnvironmentGeneration.Create(log, variables).GetAwaiter().GetResult();
var templateResolver = new TemplateResolver(fileSystem);
IAmazonCloudFormation ClientFactory() => ClientHelpers.CreateCloudFormationClient(environment);
StackArn StackProvider(RunningDeployment x) => new StackArn(stackName);
ChangeSetArn ChangesetProvider(RunningDeployment x) => new ChangeSetArn(x.Variables[AwsSpecialVariables.CloudFormation.Changesets.Arn]);
string RoleArnProvider(RunningDeployment x) => x.Variables[AwsSpecialVariables.CloudFormation.RoleArn];
var iamCapabilities = JsonConvert.DeserializeObject <List <string> >(variables.Get(AwsSpecialVariables.IamCapabilities, "[]"));
CloudFormationTemplate TemplateFactory()
{
var resolvedTemplate = templateResolver.Resolve(templateFile, filesInPackage, variables);
var resolvedParameters = templateResolver.MaybeResolve(templateParameterFile, filesInPackage, variables);
if (templateParameterFile != null && !resolvedParameters.Some())
{
throw new CommandException("Could not find template parameters file: " + templateParameterFile);
}
var parameters = CloudFormationParametersFile.Create(resolvedParameters, fileSystem, variables);
return(CloudFormationTemplate.Create(resolvedTemplate, parameters, fileSystem, variables));
}
var stackEventLogger = new StackEventLogger(log);
var conventions = new List <IConvention>
{
new LogAwsUserInfoConvention(environment),
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
//Create or Update the stack using changesets
new AggregateInstallationConvention(
new GenerateCloudFormationChangesetNameConvention(log),
new CreateCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, RoleArnProvider, TemplateFactory, iamCapabilities),
new DescribeCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider),
new ExecuteCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider, waitForComplete)
.When(ImmediateChangesetExecution),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider, () => TemplateFactory().HasOutputs)
.When(ImmediateChangesetExecution)
).When(ChangesetsEnabled),
//Create or update stack using a template (no changesets)
new AggregateInstallationConvention(
new DeployAwsCloudFormationConvention(
ClientFactory,
TemplateFactory,
stackEventLogger,
StackProvider,
RoleArnProvider,
waitForComplete,
stackName,
iamCapabilities,
disableRollback,
environment),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider, () => TemplateFactory().HasOutputs)
)
.When(ChangesetsDisabled)
};
var deployment = new RunningDeployment(pathToPackage, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
conventionRunner.RunConventions();
return(0);
}
protected void Application_Start()
{
// TODO maybe put this somewhere else (not in global.asax)
// TODO maybe move all of this into the App class with "IAppConfig"
// initialize logger
TraceListener traceListener =
new TextWriterTraceListener(Path.Combine(AppConfig.LogPath,
string.Format("repository_{0:yyyy'-'MM'-'dd__HHmmss}.log",
DateTime.Now)));
// TODO introduce flags/settings for controlling logging levels, but for now include everything
traceListener.Filter = new EventTypeFilter(SourceLevels.All);
traceListener.TraceOutputOptions = TraceOptions.ThreadId | TraceOptions.DateTime;
Web.TraceSources.Content.Listeners.Add(traceListener);
Web.TraceSources.AddInManager.Listeners.Add(traceListener);
Repository.TraceSources.ContentManagerSource.Listeners.Add(traceListener);
Repository.TraceSources.ContentSearcherSource.Listeners.Add(traceListener);
// this might be stupid, but it fixes things for iisexpress
Directory.SetCurrentDirectory(HostingEnvironment.ApplicationPhysicalPath);
// set up add-in system
AddInSource officalSource = new AddInSource("Official LostDoc repository add-in feed",
AppConfig.AddInRepository,
isOfficial: true);
// intialize MEF
// core 'add-ins'
var currentAssembly = Assembly.GetExecutingAssembly();
var assemblyName = currentAssembly.GetName();
string corePackageId = assemblyName.Name;
string corePackageVersion = assemblyName.Version.ToString();
AggregateCatalog catalog = new AggregateCatalog();
// load other sources from site-settings (not config)
AddInRepository repository = new AddInRepository(officalSource);
AddInManager addInManager = new AddInManager(repository,
AppConfig.AddInInstallPath,
AppConfig.AddInPackagePath);
// when the catalog changes, discover and route all ApiControllers
catalog.Changed += (sender, args) => this.UpdateWebApiRegistry(args);
//// TODO for debugging only
//Debugger.Break();
//Debugger.Launch();
// now register core libs
catalog.Catalogs.Add(new AddInCatalog(new ApplicationCatalog(), corePackageId, corePackageVersion));
// hook event so that installed add-ins get registered in the catalog, if composition occurs after this fires
// or if recomposition is enabled, no restart should be requried
addInManager.Installed +=
(sender, args) => catalog.Catalogs.Add(new AddInCatalog(new DirectoryCatalog(args.InstallationPath),
args.Package.Id,
args.Package.Version));
// delete and redeploy all installed packages, this will trigger the Installed event ^
// this acts as a crude "remove/overwrite plugins that were in use when un/installed" hack
addInManager.Restore();
// create container
CompositionContainer container = new CompositionContainer(catalog);
// set up template resolver
var lazyProviders = container.GetExports <IFileProvider>(ContractNames.TemplateProvider);
var realProviders = lazyProviders.Select(lazy => lazy.Value);
TemplateResolver templateResolver = new TemplateResolver(realProviders.ToArray());
// load template
Template template = new Template(container);
template.Load(templateResolver, AppConfig.Template);
// set up content manager
ContentManager contentManager = new ContentManager(new ContentSettings
{
ContentPath = AppConfig.ContentPath,
// TODO make this configurable
IgnoreVersionComponent = VersionComponent.Patch,
RepositoryPath = AppConfig.RepositoryPath,
Template = template
});
// set up notifaction system
NotificationManager notifications = new NotificationManager();
// initialize app-singleton
App.Initialize(container, contentManager, addInManager, notifications, traceListener);
// MVC init
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
// inject our custom IControllerFactory for the Admin interface
IControllerFactory oldControllerFactory = ControllerBuilder.Current.GetControllerFactory();
IControllerFactory newControllerFactory = new AddInControllerFactory(AdministrationAreaRegistration.Name,
container,
oldControllerFactory);
ControllerBuilder.Current.SetControllerFactory(newControllerFactory);
// TODO figure out if we actually need this
// hook in our MEF based IHttpController instead of the default one
//GlobalConfiguration.Configuration.Services.Replace(typeof(IHttpControllerTypeResolver), new AddInHttpControllerTypeResolver(App.Instance.Container));
}
