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); }
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)); }