Example #1
0
 public void SetUp()
 {
     Engine = new Engine();
     Engine.FileSystem.FileProviders.Add(NormalizedPath.DefaultFileProvider.Scheme, GetFileProvider());
     Engine.FileSystem.RootPath = "/";
     Engine.FileSystem.InputPaths.Clear();
     Engine.FileSystem.InputPaths.Add("/TestFiles/Input");
     Pipeline = new Pipeline("Pipeline", null);
     Context = new ExecutionContext(Engine, Pipeline);
     Inputs = new[] { Context.GetDocument() };
 }
Example #2
0
 public void SetUp()
 {
     Engine = new Engine();
     Engine.FileSystem.FileProviders.Add(NormalizedPath.DefaultFileProvider.Scheme, GetFileProvider());
     Engine.FileSystem.RootPath = "/";
     Engine.FileSystem.InputPaths.Clear();
     Engine.FileSystem.InputPaths.Add("/TestFiles/Input");
     Pipeline = new ExecutionPipeline("Pipeline", (IModuleList)null);
     Context  = new ExecutionContext(Engine, Guid.Empty, Pipeline);
     Inputs   = new[] { Context.GetDocument() };
 }
Example #3
0
 public void SetUp()
 {
     Engine = new Engine();
     Engine.FileSystem.FileProviders.Add(string.Empty, GetFileProvider());
     Engine.FileSystem.RootPath = "/";
     Engine.FileSystem.InputPaths.Clear();
     Engine.FileSystem.InputPaths.Add("/TestFiles/Input");
     Pipeline = new Pipeline("Pipeline", null);
     Context  = new ExecutionContext(Engine, Pipeline);
     Inputs   = new[] { Context.GetDocument() };
 }
Example #4
0
            public void SitemapGeneratedWithSitemapItemAsString(string hostname, string formatterString, string expected)
            {
                // Given
                Engine engine = new Engine();

                if (!string.IsNullOrWhiteSpace(hostname))
                {
                    engine.Settings[Keys.Host] = hostname;
                }
                ExecutionPipeline contentPipeline = new ExecutionPipeline("Content", (IModuleList)null);
                IExecutionContext context         = new ExecutionContext(engine, Guid.Empty, contentPipeline);

                IDocument doc = context.GetDocument(context.GetContentStream("Test"), new[]
                {
                    new KeyValuePair <string, object>(Keys.RelativeFilePath, "sub/testfile.html")
                });

                IDocument[] inputs = { doc };

                Core.Modules.Metadata.Meta m = new Core.Modules.Metadata.Meta(
                    Keys.SitemapItem,
                    (d, c) => d[Keys.RelativeFilePath].ToString());
                var outputs = m.Execute(inputs, context);

                Func <string, string> formatter = null;

                if (!string.IsNullOrWhiteSpace(formatterString))
                {
                    formatter = f => string.Format(formatterString, f);
                }

                // When
                Sitemap          sitemap = new Sitemap(formatter);
                List <IDocument> results = sitemap.Execute(outputs.ToList(), context).ToList();

                foreach (IDocument document in inputs.Concat(outputs.ToList()))
                {
                    ((IDisposable)document).Dispose();
                }

                // Then
                Assert.AreEqual(1, results.Count);
                Assert.That(results[0].Content, Does.Contain($"<loc>{expected}</loc>"));
            }
Example #5
0
            public void SitemapGeneratedWithSitemapItemAsString(string hostname, string formatterString, string expected)
            {
                // Given
                Engine engine = new Engine();
                if (!string.IsNullOrWhiteSpace(hostname))
                {
                    engine.Settings.Host = hostname;
                }
                Pipeline contentPipeline = new Pipeline("Content", null);
                IExecutionContext context = new ExecutionContext(engine, contentPipeline);

                IDocument doc = context.GetDocument("Test", new[]
                {
                    new KeyValuePair<string, object>(Keys.RelativeFilePath, "sub/testfile.html")
                });
                IDocument[] inputs = {doc};

                Core.Modules.Metadata.Meta m = new Core.Modules.Metadata.Meta(Keys.SitemapItem,
                    (d, c) => d[Keys.RelativeFilePath].ToString());
                var outputs = m.Execute(inputs, context);

                Func<string, string> formatter = null;

                if (!string.IsNullOrWhiteSpace(formatterString))
                    formatter = f => string.Format(formatterString, f);

                // When
                Sitemap sitemap = new Sitemap(formatter);
                List<IDocument> results = sitemap.Execute(outputs.ToList(), context).ToList();

                foreach (IDocument document in inputs.Concat(outputs.ToList()))
                {
                    ((IDisposable) document).Dispose();
                }

                // Then
                Assert.AreEqual(1, results.Count);
                Assert.That(results[0].Content, Does.Contain($"<loc>{expected}</loc>"));
            }
Example #6
0
        // This executes the specified modules with the specified input documents
        public IReadOnlyList <IDocument> Execute(ExecutionContext context, IEnumerable <IModule> modules, ImmutableArray <IDocument> documents)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException(nameof(Pipeline));
            }

            foreach (IModule module in modules.Where(x => x != null))
            {
                string moduleName = module.GetType().Name;
                System.Diagnostics.Stopwatch stopwatch = System.Diagnostics.Stopwatch.StartNew();
                using (Trace.WithIndent().Verbose("Executing module {0} with {1} input document(s)", moduleName, documents.Length))
                {
                    try
                    {
                        // Execute the module
                        IEnumerable <IDocument> outputs = module.Execute(documents, context.Clone(module));
                        documents = outputs?.Where(x => x != null).ToImmutableArray() ?? ImmutableArray <IDocument> .Empty;

                        // Remove any documents that were previously processed (checking will also mark the cache entry as hit)
                        if (_previouslyProcessedCache != null && _processedSources != null)
                        {
                            ImmutableArray <IDocument> .Builder newDocuments = ImmutableArray.CreateBuilder <IDocument>();
                            foreach (IDocument document in documents)
                            {
                                if (_processedSources.ContainsKey(document.Source))
                                {
                                    // We've seen this source before and already added it to the processed cache
                                    newDocuments.Add(document);
                                }
                                else
                                {
                                    List <IDocument> processedDocuments;
                                    if (!_previouslyProcessedCache.TryGetValue(document, out processedDocuments))
                                    {
                                        // This document was not previously processed, so add it to the current result and set up a list to track final results
                                        newDocuments.Add(document);
                                        processedDocuments = new List <IDocument>();
                                        _previouslyProcessedCache.Set(document, processedDocuments);
                                        _processedSources.Add(document.Source, processedDocuments);
                                    }
                                    // Otherwise, this document was previously processed so don't add it to the results
                                }
                            }
                            if (newDocuments.Count != documents.Length)
                            {
                                Trace.Verbose("Removed {0} previously processed document(s)", documents.Length - newDocuments.Count);
                            }
                            documents = newDocuments.ToImmutable();
                        }

                        // Set results in engine and trace
                        context.Engine.DocumentCollection.Set(Name, documents);
                        stopwatch.Stop();
                        Trace.Verbose("Executed module {0} in {1} ms resulting in {2} output document(s)",
                                      moduleName, stopwatch.ElapsedMilliseconds, documents.Length);
                    }
                    catch (Exception)
                    {
                        Trace.Error("Error while executing module {0}", moduleName);
                        documents = ImmutableArray <IDocument> .Empty;
                        context.Engine.DocumentCollection.Set(Name, documents);
                        throw;
                    }
                }
            }
            return(documents);
        }
Example #7
0
 private ExecutionContext(ExecutionContext original, IModule module)
 {
     Engine    = original.Engine;
     _pipeline = original._pipeline;
     Module    = module;
 }