public void GetFileInfoReturnsNotFoundFileInfoForRelativePathAboveRootPath()
 {
     using (var provider = new PhysicalFileProvider(Path.GetTempPath()))
     {
         var info = provider.GetFileInfo(Path.Combine("..", Guid.NewGuid().ToString()));
         Assert.IsType(typeof(NotFoundFileInfo), info);
     }
 }
 public void GetFileInfoReturnsNotFoundFileInfoForEmptyPath()
 {
     using (var provider = new PhysicalFileProvider(Path.GetTempPath()))
     {
         var info = provider.GetFileInfo(string.Empty);
         Assert.IsType(typeof(NotFoundFileInfo), info);
     }
 }
 private static void UseDocumentation(IApplicationBuilder app, IApplicationEnvironment appEnv)
 {
     var documentationFilesProvider = new PhysicalFileProvider(appEnv.ApplicationBasePath);
     app.UseDocumentation(new DocumentationOptions()
     {
         DefaultFileName = "index",
         RequestPath = "/docs",
         NotFoundHtmlFile = documentationFilesProvider.GetFileInfo("DocumentationTemplates\\NotFound.html"),
         LayoutFile = documentationFilesProvider.GetFileInfo("DocumentationTemplates\\Layout.html")
     });
 }
        public void ExistingFilesReturnTrue()
        {
            var provider = new PhysicalFileProvider(Environment.CurrentDirectory);
            var info = provider.GetFileInfo("File.txt");
            info.ShouldNotBe(null);
            info.Exists.ShouldBe(true);

            info = provider.GetFileInfo("/File.txt");
            info.ShouldNotBe(null);
            info.Exists.ShouldBe(true);
        }
        public void ExistingFilesReturnTrue()
        {
            var provider = new PhysicalFileProvider(Directory.GetCurrentDirectory());
            var info = provider.GetFileInfo("File.txt");
            Assert.NotNull(info);
            Assert.True(info.Exists);

            info = provider.GetFileInfo("/File.txt");
            Assert.NotNull(info);
            Assert.True(info.Exists);
        }
 public async Task NoMatch_PassesThrough(string baseUrl, string baseDir, string requestUrl)
 {
     using (var fileProvider = new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), baseDir)))
     {
         var server = StaticFilesTestServer.Create(app => app.UseStaticFiles(options =>
         {
             options.RequestPath = new PathString(baseUrl);
             options.FileProvider = fileProvider;
         }));
         var response = await server.CreateRequest(requestUrl).GetAsync();
         Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
     }
 }
Example #7
0
 public void Configure(IApplicationBuilder app, IApplicationEnvironment environemnt)
 {
     app.UseIISPlatformHandler();            
     app.UseFileServer();
     
     var provider = new PhysicalFileProvider(Path.Combine(environemnt.ApplicationBasePath, "node_modules"));
     var options = new FileServerOptions();
     options.RequestPath = "/node_modules";            
     options.StaticFileOptions.FileProvider = provider;
     options.EnableDirectoryBrowsing = true; 
     app.UseFileServer(options);
     
     app.UseMvc();            
 }
        public void DisplaysSourceCodeLines_ForAbsolutePaths(string absoluteFilePath)
        {
            // Arrange
            var rootPath = Directory.GetCurrentDirectory();
            // PhysicalFileProvider handles only relative paths but we fall back to work with absolute paths too
            var provider = new PhysicalFileProvider(rootPath);

            // Act
            var middleware = GetErrorPageMiddleware(provider);
            var stackFrame = middleware.GetStackFrame("func1", absoluteFilePath, lineNumber: 10);

            // Assert
            // Lines 4-16 (inclusive) is the code block
            Assert.Equal(4, stackFrame.PreContextLine);
            Assert.Equal(GetCodeLines(4, 9), stackFrame.PreContextCode);
            Assert.Equal(GetCodeLines(10, 10), stackFrame.ContextCode);
            Assert.Equal(GetCodeLines(11, 16), stackFrame.PostContextCode);
        }
        public void GetFileInfoReturnsNotFoundFileInfoForHiddenFile()
        {
            using (var root = new DisposableFileSystem())
            {
                using (var provider = new PhysicalFileProvider(root.RootPath))
                {
                    var fileName = Guid.NewGuid().ToString();
                    var filePath = Path.Combine(root.RootPath, fileName);
                    File.Create(filePath);
                    var fileInfo = new FileInfo(filePath);
                    File.SetAttributes(filePath, fileInfo.Attributes | FileAttributes.Hidden);

                    var info = provider.GetFileInfo(fileName);

                    Assert.IsType(typeof(NotFoundFileInfo), info);
                }
            }
        }
        public async Task NoMatch_PassesThrough(string baseUrl, string baseDir, string requestUrl)
        {
            using (var fileProvider = new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), baseDir)))
            {
                var server = StaticFilesTestServer.Create(app =>
                {
                    app.UseDefaultFiles(options =>
                    {
                        options.RequestPath = new PathString(baseUrl);
                        options.FileProvider = fileProvider;
                    });
                    app.Run(context => context.Response.WriteAsync(context.Request.Path.Value));
                });

                var response = await server.CreateClient().GetAsync(requestUrl);
                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.Equal(requestUrl, await response.Content.ReadAsStringAsync()); // Should not be modified
            }
        }
        /// <inheritdoc />
        /// <remarks>Pre-compiles all Razor views in the application.</remarks>
        public virtual void BeforeCompile(IBeforeCompileContext context)
        {
            var compilerOptionsProvider = _appServices.GetRequiredService<ICompilerOptionsProvider>();
            var loadContextAccessor = _appServices.GetRequiredService<IAssemblyLoadContextAccessor>();
            var compilationSettings = GetCompilationSettings(compilerOptionsProvider, context.ProjectContext);
            var fileProvider = new PhysicalFileProvider(context.ProjectContext.ProjectDirectory);

            var viewCompiler = new RazorPreCompiler(
                context,
                loadContextAccessor,
                fileProvider,
                _memoryCache,
                compilationSettings)
            {
                GenerateSymbols = GenerateSymbols
            };

            viewCompiler.CompileViews();
        }
Example #12
0
        private static JSPool.IJsPool CreateJSEngine(IServiceProvider provider)
        {
            var ieConfig = new JavaScriptEngineSwitcher.Msie.Configuration.MsieConfiguration
            {
                EngineMode = JavaScriptEngineSwitcher.Msie.JsEngineMode.ChakraEdgeJsRt
                
            };

            var appEnv = provider.GetRequiredService<IApplicationEnvironment>();
            var fileProvider = new PhysicalFileProvider(appEnv.ApplicationBasePath);
            var jsPath = fileProvider.GetFileInfo("wwwroot/js/server.js").PhysicalPath;

            var poolConfig = new JSPool.JsPoolConfig();
            poolConfig.MaxUsagesPerEngine = 20;
            poolConfig.StartEngines = 2;
            poolConfig.EngineFactory = () => new JavaScriptEngineSwitcher.Msie.MsieJsEngine(ieConfig);
            poolConfig.Initializer = engine => InitialiseJSRuntime(jsPath, engine);
            poolConfig.WatchFiles = new[] { jsPath };
            return new JSPool.JsPool(poolConfig);
        }
        public static IConfigurationRoot ReloadOnChanged(
            this IConfigurationRoot config,
            string basePath,
            string filename)
        {
            if (config == null)
            {
                throw new ArgumentNullException(nameof(config));
            }

            if (basePath == null)
            {
                throw new ArgumentNullException(nameof(basePath));
            }

            if (filename == null)
            {
                throw new ArgumentNullException(nameof(filename));
            }

            var fileProvider = new PhysicalFileProvider(basePath);
            return ReloadOnChanged(config, fileProvider, filename);
        }
Example #14
0
        public void Main(string[] args)
        {
            Console.WriteLine("Root path      : {0}", _appEnvironment.ApplicationBasePath);
            Console.WriteLine();

            var physicalFileProvider = new PhysicalFileProvider(_appEnvironment.ApplicationBasePath);
            physicalFileProvider.GetInfo(@"c:\github\kichalla\FileProvidersExample\src\FileProvidersExample\Program.cs");
            physicalFileProvider.GetInfo("Program.cs");
            physicalFileProvider.GetInfo("/Program.cs");
            physicalFileProvider.GetInfo(@"\Program.cs");
            physicalFileProvider.GetInfo("FileProvidersExample/Program.cs");
            physicalFileProvider.GetInfo("/FileProvidersExample/Program.cs");
            physicalFileProvider.GetInfo(@"\FileProvidersExample\Program.cs");

            Console.WriteLine("***********************************************************");

            var embeddedProvider = new EmbeddedFileProvider(this.GetType().GetTypeInfo().Assembly, "FileProvidersExample.EmbeddedResources");
            embeddedProvider.GetInfo("Blah.cshtml");
            embeddedProvider.GetInfo("/Views/Home/Index.cshtml");
            embeddedProvider.GetInfo("Views/Home/Index.cshtml");
            embeddedProvider.GetInfo(@"\Views\Home\Index.cshtml");
            embeddedProvider.GetInfo(@"Views\Home\Index.cshtml");
        }
        public async Task Triggers_With_Regular_Expression_Pointing_To_SubFolder()
        {
            var subFolderName = Guid.NewGuid().ToString();
            var pattern1 = "**/*";
            var pattern2 = string.Format("{0}/**/*.cshtml", subFolderName);
            var root = Path.GetTempPath();
            var fileName = Guid.NewGuid().ToString();
            var subFolder = Path.Combine(root, subFolderName);
            Directory.CreateDirectory(subFolder);

            int pattern1TriggerCount = 0, pattern2TriggerCount = 0;
            var provider = new PhysicalFileProvider(root);
            var trigger1 = provider.Watch(pattern1);
            trigger1.RegisterExpirationCallback(_ => { pattern1TriggerCount++; }, null);
            var trigger2 = provider.Watch(pattern2);
            trigger2.RegisterExpirationCallback(_ => { pattern2TriggerCount++; }, null);

            File.WriteAllText(Path.Combine(root, fileName + ".cshtml"), "Content");

            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            pattern1TriggerCount.ShouldBe(1);
            pattern2TriggerCount.ShouldBe(0);

            trigger1 = provider.Watch(pattern1);
            trigger1.RegisterExpirationCallback(_ => { pattern1TriggerCount++; }, null);
            // Register this trigger again.
            var trigger3 = provider.Watch(pattern2);
            trigger3.RegisterExpirationCallback(_ => { pattern2TriggerCount++; }, null);
            trigger3.ShouldBe(trigger2);
            File.WriteAllText(Path.Combine(subFolder, fileName + ".cshtml"), "Content");

            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            pattern1TriggerCount.ShouldBe(2);
            pattern2TriggerCount.ShouldBe(2);

            Directory.Delete(subFolder, true);
            File.Delete(Path.Combine(root, fileName + ".cshtml"));
        }
        public async Task Triggers_With_Regular_Expression_Filters()
        {
            var pattern1 = "**/*";
            var pattern2 = "*.cshtml";
            var root = Path.GetTempPath();
            var fileName = Guid.NewGuid().ToString();
            var subFolder = Path.Combine(root, Guid.NewGuid().ToString());
            Directory.CreateDirectory(subFolder);

            int pattern1TriggerCount = 0, pattern2TriggerCount = 0;
            Action<object> callback1 = _ => { pattern1TriggerCount++; };
            Action<object> callback2 = _ => { pattern2TriggerCount++; };

            var provider = new PhysicalFileProvider(root);
            var trigger1 = provider.Watch(pattern1);
            trigger1.RegisterExpirationCallback(callback1, null);
            var trigger2 = provider.Watch(pattern2);
            trigger2.RegisterExpirationCallback(callback2, null);

            File.WriteAllText(Path.Combine(root, fileName + ".cshtml"), "Content");

            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            pattern1TriggerCount.ShouldBe(1);
            pattern2TriggerCount.ShouldBe(1);

            trigger1 = provider.Watch(pattern1);
            trigger1.RegisterExpirationCallback(callback1, null);
            trigger2 = provider.Watch(pattern2);
            trigger2.RegisterExpirationCallback(callback2, null);
            File.WriteAllText(Path.Combine(subFolder, fileName + ".txt"), "Content");

            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            pattern1TriggerCount.ShouldBe(2);
            pattern2TriggerCount.ShouldBe(1);

            Directory.Delete(subFolder, true);
            File.Delete(Path.Combine(root, fileName + ".cshtml"));
        }
        public async Task Triggers_With_Path_Not_Ending_With_Slash()
        {
            var provider = new PhysicalFileProvider(Path.GetTempPath());
            string directoryName = Guid.NewGuid().ToString();
            string fileName = Guid.NewGuid().ToString();

            int triggerCount = 0;
            // Matches file/directory with this name.
            var fileTrigger = provider.Watch("/" + directoryName);
            fileTrigger.RegisterExpirationCallback(_ => { triggerCount++; }, null);

            Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), directoryName));
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            triggerCount.ShouldBe(1);

            // Matches file/directory with this name.
            fileTrigger = provider.Watch("/" + fileName);
            fileTrigger.RegisterExpirationCallback(_ => { triggerCount++; }, null);

            File.WriteAllText(Path.Combine(Path.GetTempPath(), fileName), "Content");
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            triggerCount.ShouldBe(2);
        }
        public async Task Triggers_With_Path_Ending_With_Slash()
        {
            var provider = new PhysicalFileProvider(Path.GetTempPath());
            string fileName = Guid.NewGuid().ToString();
            string folderName = Guid.NewGuid().ToString();

            int triggerCount = 0;
            var fileTrigger = provider.Watch("/" + folderName + "/");
            fileTrigger.RegisterExpirationCallback(_ => { triggerCount++; }, null);

            var folderPath = Path.Combine(Path.GetTempPath(), folderName);
            Directory.CreateDirectory(folderPath);
            File.WriteAllText(Path.Combine(folderPath, fileName), "Content");

            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            triggerCount.ShouldBe(1);

            fileTrigger = provider.Watch("/" + folderName + "/");
            fileTrigger.RegisterExpirationCallback(_ => { triggerCount++; }, null);

            File.AppendAllText(Path.Combine(folderPath, fileName), "UpdatedContent");
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            triggerCount.ShouldBe(2);

            fileTrigger = provider.Watch("/" + folderName + "/");
            fileTrigger.RegisterExpirationCallback(_ => { triggerCount++; }, null);

            File.Delete(Path.Combine(folderPath, fileName));
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            triggerCount.ShouldBe(3);
        }
        public async Task Trigger_Fired_For_File_Or_Directory_Create_And_Delete()
        {
            var root = Path.GetTempPath();
            var provider = new PhysicalFileProvider(root);
            string fileName = Guid.NewGuid().ToString();
            string directoryName = Guid.NewGuid().ToString();

            int triggerCount = 0;
            var fileTrigger = provider.Watch(fileName);
            fileTrigger.RegisterExpirationCallback(_ => { triggerCount++; }, null);
            var directoryTrigger = provider.Watch(directoryName);
            directoryTrigger.RegisterExpirationCallback(_ => { triggerCount++; }, null);

            fileTrigger.ShouldNotBe(directoryTrigger);

            File.WriteAllText(Path.Combine(root, fileName), "Content");
            Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), directoryName));

            // Wait for triggers to fire.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);

            triggerCount.ShouldBe(2);

            fileTrigger.IsExpired.ShouldBe(true);
            directoryTrigger.IsExpired.ShouldBe(true);

            fileTrigger = provider.Watch(fileName);
            fileTrigger.RegisterExpirationCallback(_ => { triggerCount++; }, null);
            directoryTrigger = provider.Watch(directoryName);
            directoryTrigger.RegisterExpirationCallback(_ => { triggerCount++; }, null);

            File.Delete(Path.Combine(root, fileName));
            Directory.Delete(Path.Combine(Path.GetTempPath(), directoryName));

            // Wait for triggers to fire.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            triggerCount.ShouldBe(4);
        }
        public void Trigger_For_Null_Empty_Whitespace_Filters()
        {
            var provider = new PhysicalFileProvider(Path.GetTempPath());

            var trigger = provider.Watch(null);
            trigger.IsExpired.ShouldBe(false);
            trigger.ActiveExpirationCallbacks.ShouldBe(false);

            trigger = provider.Watch(string.Empty);
            trigger.IsExpired.ShouldBe(false);
            trigger.ActiveExpirationCallbacks.ShouldBe(true);

            // White space.
            trigger = provider.Watch("  ");
            trigger.IsExpired.ShouldBe(false);
            trigger.ActiveExpirationCallbacks.ShouldBe(true);

            // Absolute path.
            trigger = provider.Watch(Path.Combine(Path.GetTempPath() + "filename"));
            trigger.IsExpired.ShouldBe(false);
            trigger.ActiveExpirationCallbacks.ShouldBe(false);
        }
        public async Task ModifyContent_And_Delete_File_Succeeds_And_Callsback_Registered_Triggers()
        {
            var fileName     = Guid.NewGuid().ToString();
            var fileLocation = Path.Combine(Path.GetTempPath(), fileName);

            File.WriteAllText(fileLocation, "OldContent");
            var provider = new PhysicalFileProvider(Path.GetTempPath());
            var fileInfo = provider.GetFileInfo(fileName);

            Assert.Equal(new FileInfo(fileInfo.PhysicalPath).Length, fileInfo.Length);
            Assert.True(fileInfo.Exists);

            IExpirationTrigger trigger3 = null, trigger4 = null;
            var trigger1 = provider.Watch(fileName);
            var trigger2 = provider.Watch(fileName);

            // Valid trigger1 created.
            Assert.NotNull(trigger1);
            Assert.False(trigger1.IsExpired);
            Assert.True(trigger1.ActiveExpirationCallbacks);

            // Valid trigger2 created.
            Assert.NotNull(trigger2);
            Assert.False(trigger2.IsExpired);
            Assert.True(trigger2.ActiveExpirationCallbacks);

            // Trigger is the same for a specific file.
            Assert.Equal(trigger2, trigger1);

            trigger1.RegisterExpirationCallback(state =>
            {
                var infoFromState = state as IFileInfo;
                trigger3          = provider.Watch(infoFromState.Name);
                Assert.NotNull(trigger3);
                trigger3.RegisterExpirationCallback(_ => { }, null);
                Assert.False(trigger3.IsExpired);
            }, state: fileInfo);

            trigger2.RegisterExpirationCallback(state =>
            {
                var infoFromState = state as IFileInfo;
                trigger4          = provider.Watch(infoFromState.Name);
                Assert.NotNull(trigger4);
                trigger4.RegisterExpirationCallback(_ => { }, null);
                Assert.False(trigger4.IsExpired);
            }, state: fileInfo);

            // Write new content.
            File.WriteAllText(fileLocation, "OldContent + NewContent");
            Assert.True(fileInfo.Exists);
            // Wait for callbacks to be fired.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);

            Assert.True(trigger1.IsExpired);
            Assert.True(trigger2.IsExpired);

            // Trigger is the same for a specific file.
            Assert.Equal(trigger4, trigger3);
            // A new trigger is created.
            Assert.NotEqual(trigger1, trigger3);

            // Delete the file and verify file info is updated.
            File.Delete(fileLocation);
            fileInfo = provider.GetFileInfo(fileName);
            Assert.False(fileInfo.Exists);
            Assert.False(new FileInfo(fileLocation).Exists);

            // Wait for callbacks to be fired.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);

            Assert.True(trigger3.IsExpired);
            Assert.True(trigger4.IsExpired);
        }
        public async Task Triggers_NotFired_For_FileNames_Starting_With_Period_And_Hidden_Files()
        {
            var root = Path.GetTempPath();
            var hiddenFileName = Path.Combine(root, Guid.NewGuid().ToString());
            File.WriteAllText(hiddenFileName, "Content");
            var systemFileName = Path.Combine(root, Guid.NewGuid().ToString());
            File.WriteAllText(systemFileName, "Content");
            var fileNameStartingWithPeriod = Path.Combine(root, "." + Guid.NewGuid().ToString());
            File.WriteAllText(fileNameStartingWithPeriod, "Content");
            var fileInfo = new FileInfo(hiddenFileName);
            File.SetAttributes(hiddenFileName, fileInfo.Attributes | FileAttributes.Hidden);
            fileInfo = new FileInfo(systemFileName);
            File.SetAttributes(systemFileName, fileInfo.Attributes | FileAttributes.System);

            var provider = new PhysicalFileProvider(Path.GetTempPath());
            var hiddenFileTrigger = provider.Watch(Path.GetFileName(hiddenFileName));
            var triggerFileNameStartingPeriod = provider.Watch(Path.GetFileName(fileNameStartingWithPeriod));
            var systemFileTrigger = provider.Watch(Path.GetFileName(systemFileName));

            hiddenFileTrigger.IsExpired.ShouldBe(false);
            triggerFileNameStartingPeriod.IsExpired.ShouldBe(false);
            systemFileTrigger.IsExpired.ShouldBe(false);

            File.AppendAllText(hiddenFileName, "Appending text");
            File.WriteAllText(fileNameStartingWithPeriod, "Updated Contents");
            File.AppendAllText(systemFileName, "Appending text");

            // Wait for triggers to fire.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);

            hiddenFileTrigger.IsExpired.ShouldBe(false);
            triggerFileNameStartingPeriod.IsExpired.ShouldBe(false);
            systemFileTrigger.IsExpired.ShouldBe(false);
        }
        public async Task FileTrigger_NotTriggered_After_Expiry()
        {
            var fileName = Guid.NewGuid().ToString();
            var fileLocation = Path.Combine(Path.GetTempPath(), fileName);
            File.WriteAllText(fileLocation, "Content");
            var provider = new PhysicalFileProvider(Path.GetTempPath());

            var expirationTrigger = provider.Watch(fileName);
            int invocationCount = 0;
            expirationTrigger.RegisterExpirationCallback(_ => { invocationCount++; }, null);

            // Callback expected for this change.
            File.AppendAllText(fileLocation, "UpdatedContent1");

            // Callback not expected for this change.
            File.AppendAllText(fileLocation, "UpdatedContent2");

            // Wait for callbacks to be fired.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);

            invocationCount.ShouldBe(1);

            File.Delete(fileLocation);
        }
        public async Task Createdtrigger_Same_For_A_File_And_Callsback_AllRegisteredTriggers_OnChange()
        {
            var fileName = Guid.NewGuid().ToString();
            var fileLocation = Path.Combine(Path.GetTempPath(), fileName);
            File.WriteAllText(fileLocation, "Content");
            var provider = new PhysicalFileProvider(Path.GetTempPath());

            var count = 10;
            var tasks = new List<Task>(count);
            var triggers = new IExpirationTrigger[count];
            var callbackResults = new bool[count];

            for (int i = 0; i < count; i++)
            {
                tasks.Add(new Task(index =>
                {
                    var expirationTrigger = provider.Watch(fileName);
                    triggers[(int)index] = expirationTrigger;
                    expirationTrigger.ShouldNotBe(null);
                    expirationTrigger.IsExpired.ShouldNotBe(true);
                    expirationTrigger.RegisterExpirationCallback(_ => { callbackResults[(int)index] = true; }, index);
                }, state: i));
            }

            // Simulating multiple concurrent requests to the same file.
            Parallel.ForEach(tasks, task => task.Start());
            await Task.WhenAll(tasks);
            File.AppendAllText(fileLocation, "UpdatedContent");

            // Some warm up time for the callbacks to be fired.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);

            for (int index = 1; index < count; index++)
            {
                triggers[index].ShouldBe(triggers[index - 1]);
            }

            callbackResults.All(c => c == true).ShouldBe(true);

            File.Delete(fileLocation);
        }
        public void Triggers_With_Forward_And_Backward_Slash()
        {
            var provider = new PhysicalFileProvider(Path.GetTempPath());
            var trigger1 = provider.Watch("/a/b");
            var trigger2 = provider.Watch("a/b");
            var trigger3 = provider.Watch(@"a\b");

            trigger1.ShouldBe(trigger2);
            trigger2.ShouldBe(trigger3);

            trigger1.ActiveExpirationCallbacks.ShouldBe(true);
            trigger2.ActiveExpirationCallbacks.ShouldBe(true);
            trigger3.ActiveExpirationCallbacks.ShouldBe(true);

            trigger1.IsExpired.ShouldBe(false);
            trigger2.IsExpired.ShouldBe(false);
            trigger3.IsExpired.ShouldBe(false);
        }
        public async Task Trigger_Fired_On_Directory_Name_Change()
        {
            var provider = new PhysicalFileProvider(Path.GetTempPath());
            var oldDirectoryName = Guid.NewGuid().ToString();
            var newDirectoryName = Guid.NewGuid().ToString();
            var oldDirectoryFullPath = Path.Combine(Path.GetTempPath(), oldDirectoryName);
            var newDirectoryFullPath = Path.Combine(Path.GetTempPath(), newDirectoryName);

            Directory.CreateDirectory(oldDirectoryFullPath);
            var oldDirectoryTrigger = provider.Watch("**/" + oldDirectoryName);
            var newDirectoryTrigger = provider.Watch("**/" + newDirectoryName);
            var oldTriggers = new List<IExpirationTrigger>();
            var newTriggers = new List<IExpirationTrigger>();

            oldTriggers.Add(provider.Watch(Path.Combine("**", oldDirectoryName, "*.txt")));
            newTriggers.Add(provider.Watch(Path.Combine("**", newDirectoryName, "*.txt")));

            for (int i = 0; i < 5; i++)
            {
                var fileName = string.Format("test{0}.txt", i);
                File.WriteAllText(Path.Combine(oldDirectoryFullPath, fileName), "test content");
                oldTriggers.Add(provider.Watch(Path.Combine("**", oldDirectoryName, fileName)));
                newTriggers.Add(provider.Watch(Path.Combine("**", newDirectoryName, fileName)));
            }

            await Task.Delay(2 * 100); // Give it a while before trying rename.
            Directory.Move(oldDirectoryFullPath, newDirectoryFullPath);

            // Wait for triggers to fire.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            oldDirectoryTrigger.IsExpired.ShouldBe(true);
            newDirectoryTrigger.IsExpired.ShouldBe(true);
            oldTriggers.All(t => t.IsExpired).ShouldBe(true);
            newTriggers.All(t => t.IsExpired).ShouldBe(true);

            newDirectoryTrigger = provider.Watch(newDirectoryName);
            newTriggers = new List<IExpirationTrigger>();

            newTriggers.Add(provider.Watch(Path.Combine("**", newDirectoryName, "*.txt")));
            for (int i = 0; i < 5; i++)
            {
                var fileName = string.Format("test{0}.txt", i);
                newTriggers.Add(provider.Watch(Path.Combine("**", newDirectoryName, fileName)));
            }

            Directory.Delete(newDirectoryFullPath, true);

            // Wait for triggers to fire.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            newDirectoryTrigger.IsExpired.ShouldBe(true);
            newTriggers.All(t => t.IsExpired).ShouldBe(true);
        }
        public async Task ModifyContent_And_Delete_File_Succeeds_And_Callsback_Registered_Triggers()
        {
            var fileName = Guid.NewGuid().ToString();
            var fileLocation = Path.Combine(Path.GetTempPath(), fileName);
            File.WriteAllText(fileLocation, "OldContent");
            var provider = new PhysicalFileProvider(Path.GetTempPath());
            var fileInfo = provider.GetFileInfo(fileName);
            fileInfo.Length.ShouldBe(new FileInfo(fileInfo.PhysicalPath).Length);
            fileInfo.Exists.ShouldBe(true);

            IExpirationTrigger trigger3 = null, trigger4 = null;
            var trigger1 = provider.Watch(fileName);
            var trigger2 = provider.Watch(fileName);

            // Valid trigger1 created.
            trigger1.ShouldNotBe(null);
            trigger1.IsExpired.ShouldBe(false);
            trigger1.ActiveExpirationCallbacks.ShouldBe(true);

            // Valid trigger2 created.
            trigger2.ShouldNotBe(null);
            trigger2.IsExpired.ShouldBe(false);
            trigger2.ActiveExpirationCallbacks.ShouldBe(true);

            // Trigger is the same for a specific file.
            trigger1.ShouldBe(trigger2);

            trigger1.RegisterExpirationCallback(state =>
            {
                var infoFromState = state as IFileInfo;
                trigger3 = provider.Watch(infoFromState.Name);
                trigger3.ShouldNotBe(null);
                trigger3.RegisterExpirationCallback(_ => { }, null);
                trigger3.IsExpired.ShouldBe(false);
            }, state: fileInfo);

            trigger2.RegisterExpirationCallback(state =>
            {
                var infoFromState = state as IFileInfo;
                trigger4 = provider.Watch(infoFromState.Name);
                trigger4.ShouldNotBe(null);
                trigger4.RegisterExpirationCallback(_ => { }, null);
                trigger4.IsExpired.ShouldBe(false);
            }, state: fileInfo);

            // Write new content.
            File.WriteAllText(fileLocation, "OldContent + NewContent");
            fileInfo.Exists.ShouldBe(true);
            // Wait for callbacks to be fired.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            trigger1.IsExpired.ShouldBe(true);
            trigger2.IsExpired.ShouldBe(true);

            // Trigger is the same for a specific file.
            trigger3.ShouldBe(trigger4);
            // A new trigger is created.
            trigger3.ShouldNotBe(trigger1);

            // Delete the file and verify file info is updated.
            File.Delete(fileLocation);
            fileInfo = provider.GetFileInfo(fileName);
            fileInfo.Exists.ShouldBe(false);
            new FileInfo(fileLocation).Exists.ShouldBe(false);

            // Wait for callbacks to be fired.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            trigger3.IsExpired.ShouldBe(true);
            trigger4.IsExpired.ShouldBe(true);
        }
Example #28
0
 public DocumentFileProvider(string root, string content)
 {
     _physicalFileProvider = new PhysicalFileProvider(root);
     _content = content;
 }
        public async Task Trigger_With_MultipleFiles()
        {
            var fileName1 = Guid.NewGuid().ToString();
            var fileName2 = Guid.NewGuid().ToString();
            var fileLocation1 = Path.Combine(Path.GetTempPath(), fileName1);
            var fileLocation2 = Path.Combine(Path.GetTempPath(), fileName2);
            File.WriteAllText(fileLocation1, "Content1");
            File.WriteAllText(fileLocation2, "Content2");
            var provider = new PhysicalFileProvider(Path.GetTempPath());

            int invocationCount1 = 0, invocationCount2 = 0;
            var trigger1 = provider.Watch(fileName1);
            trigger1.RegisterExpirationCallback(_ => { invocationCount1++; }, null);
            var trigger2 = provider.Watch(fileName2);
            trigger2.RegisterExpirationCallback(_ => { invocationCount2++; }, null);

            trigger1.ShouldNotBe(null);
            trigger1.IsExpired.ShouldNotBe(true);
            trigger1.ActiveExpirationCallbacks.ShouldBe(true);

            trigger2.ShouldNotBe(null);
            trigger2.IsExpired.ShouldNotBe(true);
            trigger2.ActiveExpirationCallbacks.ShouldBe(true);

            trigger1.ShouldNotBe(trigger2);

            File.AppendAllText(fileLocation1, "Update1");
            File.AppendAllText(fileLocation2, "Update2");

            // Wait for callbacks to be fired.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);

            invocationCount1.ShouldBe(1);
            invocationCount2.ShouldBe(1);
            trigger1.IsExpired.ShouldBe(true);
            trigger2.IsExpired.ShouldBe(true);

            File.Delete(fileLocation1);
            File.Delete(fileLocation2);

            // Callbacks not invoked on expired triggers.
            invocationCount1.ShouldBe(1);
            invocationCount2.ShouldBe(1);
        }
        public void Trigger_Is_FileName_Case_Insensitive()
        {
            var fileName = Guid.NewGuid().ToString() + 'A';
            var fileLocation = Path.Combine(Path.GetTempPath(), fileName);
            File.WriteAllText(fileLocation, "Content");
            var provider = new PhysicalFileProvider(Path.GetTempPath());

            var expirationTrigger = provider.Watch(fileName);
            var lowerCaseExpirationTrigger = provider.Watch(fileName.ToLowerInvariant());
            expirationTrigger.ShouldBe(lowerCaseExpirationTrigger);

            File.Delete(fileLocation);
        }
        public async Task Trigger_Callbacks_Are_Async_And_TriggerNotAffected_By_Exceptions()
        {
            var fileName = Guid.NewGuid().ToString();
            var fileLocation = Path.Combine(Path.GetTempPath(), fileName);
            File.WriteAllText(fileLocation, "Content");
            var provider = new PhysicalFileProvider(Path.GetTempPath());

            var expirationTrigger = provider.Watch(fileName);
            expirationTrigger.RegisterExpirationCallback(async _ =>
            {
                await Task.Delay(10 * 1000);
                throw new Exception("Callback throwing exception");
            }, null);

            File.AppendAllText(fileLocation, "UpdatedContent");
            // Wait for callback to be fired.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            expirationTrigger.IsExpired.ShouldBe(true);

            // Verify file system watcher is stable.
            int callbackCount = 0;
            var expirationTriggerAfterCallbackException = provider.Watch(fileName);
            expirationTriggerAfterCallbackException.RegisterExpirationCallback(_ => { callbackCount++; }, null);
            File.AppendAllText(fileLocation, "UpdatedContent");

            // Wait for callback to be fired.
            await Task.Delay(WAIT_TIME_FOR_TRIGGER_TO_FIRE);
            expirationTrigger.IsExpired.ShouldBe(true);
            callbackCount.ShouldBe(1);

            File.Delete(fileLocation);
        }