public FileSystemBase() { string testFolder = Path.Join(AppDomain.CurrentDomain.BaseDirectory, this.GetType().Name); if (Directory.Exists(testFolder)) { Directory.Delete(testFolder, true); } Directory.CreateDirectory(testFolder); Settings = new TetriSettings(new TestLogger <TetriSettings>()) { RepositoryPath = Path.Join(testFolder, "repository"), PackagePath = Path.Join(testFolder, "packages"), TempPath = Path.Join(testFolder, "temp"), ArchivePath = Path.Join(testFolder, "archives"), TagsPath = Path.Join(testFolder, "tags") }; Logger = new TestLogger <IIndexReader>(); TagService = new Core.TagsService( Settings, new TestLogger <ITagsService>(), new PackageListCache(MemoryCacheHelper.GetInstance())); IndexReader = new Core.IndexReader(Settings, new Core.ThreadDefault(), TagService, Logger, new FileSystem(), HashServiceHelper.Instance()); Thread.Sleep(200);// fixes race condition when scaffolding up index between consecutive tests IndexReader.Initialize(); }
/// <summary> /// Creates a package with some file data. /// </summary> /// <param name="settings"></param> /// <param name="packageName"></param> /// <returns></returns> public static TestPackage CreatePackage(ITetriSettings settings, string packageName) { // create package, files folder and item location in one byte[] content = Encoding.ASCII.GetBytes("some content"); TestPackage testPackage = new TestPackage { Content = content, Path = $"path/to/{packageName}", Hash = HashServiceHelper.Instance().FromByteArray(content), Name = packageName }; string filePathHash = HashServiceHelper.Instance().FromString(testPackage.Path); // create via workspace writer. Note that workspace has no logic of its own to handle hashing, it relies on whatever // calls it to do that. We could use PackageCreate to do this, but as we want to test PackageCreate with this helper // we keep this as low-level as possible IWorkspace workspace = new Core.Workspace(settings, new TestLogger <IWorkspace>(), HashServiceHelper.Instance()); workspace.Initialize(); workspace.AddIncomingFile(StreamsHelper.StreamFromBytes(testPackage.Content), testPackage.Path); workspace.WriteFile(testPackage.Path, testPackage.Hash, testPackage.Content.Length, testPackage.Name); workspace.WriteManifest(testPackage.Name, HashServiceHelper.Instance().FromString(filePathHash + testPackage.Hash)); return(testPackage); }
public PackageList(IMemoryCache memoryCache, ITetriSettings settings, ITagsService tagService, ILogger <IPackageList> logger) { _cache = memoryCache; _settings = settings; _tagService = tagService; _logger = logger; }
public PackageCreate(IIndexReader indexReader, ITetriSettings settings, ILogger <IPackageCreate> log, IWorkspace workspace, IHashService hashService) { _indexReader = indexReader; _log = log; _workspace = workspace; _settings = settings; _hashService = hashService; }
public IndexReader(ITetriSettings settings, IThread thread, ITagsService tagService, ILogger <IIndexReader> logger, IFileSystem fileSystem, IHashService hashService) { _settings = settings; _tagService = tagService; _logger = logger; _fileSystem = fileSystem; _hashService = hashService; _thread = thread; }
/// <summary> /// /// </summary> /// <param name="packageService"></param> /// <param name="settings"></param> /// <param name="indexService"></param> /// <param name="settings"></param> /// <param name="log"></param> public PackagesController(IPackageCreate packageService, IPackageList packageList, IPackageListCache packageListCache, IIndexReader indexService, ITetriSettings settings, ILogger <PackagesController> log) { _packageList = packageList; _packageService = packageService; _packageListCache = packageListCache; _indexService = indexService; _settings = settings; _log = log; }
/// <summary> /// Writes a manifest directly. does not generate files. Use this for manifest tests only where you need control of the manifest. /// </summary> /// <param name="settings"></param> /// <param name="manifest"></param> public static void WriteManifest(ITetriSettings settings, Manifest manifest) { Directory.CreateDirectory(Path.Combine(settings.PackagePath, manifest.Id)); File.WriteAllText(Path.Combine(settings.PackagePath, manifest.Id, "manifest.json"), JsonConvert.SerializeObject(manifest)); // create directly Manifest headCopy = JsonConvert.DeserializeObject <Manifest>(JsonConvert.SerializeObject(manifest)); headCopy.Tags = new HashSet <string>(); File.WriteAllText(Path.Combine(settings.PackagePath, manifest.Id, "manifest-head.json"), JsonConvert.SerializeObject(headCopy)); }
public TestBase() { this.Kernel = new StandardKernel(); this.Kernel.Load(Assembly.GetExecutingAssembly()); this.Settings = Kernel.Get <ITetriSettings>(); }
public HomeController(ITetriSettings settings, IIndexReader indexService, IPackageList packageList) { _settings = settings; _indexService = indexService; _packageList = packageList; }
public TagsService(ITetriSettings settings, ILogger<ITagsService> logger, IPackageListCache packageListCache) { _settings = settings; _logger = logger; _packageListCache = packageListCache; }
public static void TagPackage(ITetriSettings settings, string tag, string packageId) { Directory.CreateDirectory(Path.Combine(settings.TagsPath, Obfuscator.Cloak(tag))); File.WriteAllText(Path.Combine(settings.TagsPath, Obfuscator.Cloak(tag), packageId), string.Empty); }
/// <summary> /// Generates a valid package, returns its unique id. /// </summary> /// <returns></returns> public static TestPackage CreatePackage(ITetriSettings settings) { return(CreatePackage(settings, "somepackage")); }
public WriteLevel(ITetriSettings settings) { _settings = settings; }
/// <summary> /// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. /// </summary> /// <param name="app"></param> /// <param name="env"></param> public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/error/500"); // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. app.UseHsts(); } // register custom error pages app.Use(async(context, next) => { await next(); if (context.Response.StatusCode == 404 && !context.Response.HasStarted) { context.Request.Path = "/error/404"; await next(); } if (context.Response.StatusCode == 403 && !context.Response.HasStarted) { context.Request.Path = "/error/403"; await next(); } }); string logPath = Environment.GetEnvironmentVariable("LOG_PATH"); if (string.IsNullOrEmpty(logPath)) { logPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "data", "logs", "log.txt"); } loggerFactory.AddFile(logPath); app.UseHttpsRedirection(); app.UseStaticFiles(); app.UseCookiePolicy(); app.UseRouting(); app.UseResponseCompression(); // initialize indexes IServiceProvider serviceProvider = app.ApplicationServices; IEnumerable <IIndexReader> indexReaders = serviceProvider.GetServices <IIndexReader>(); foreach (IIndexReader indexReader in indexReaders) { indexReader.Initialize(); } Daemon daemon = serviceProvider.GetService <Daemon>(); int daemonInterval = 1000 * 60 * 10; // 60000 = 10 minutes if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("DAEMON_INTERVAL"))) { int.TryParse(Environment.GetEnvironmentVariable("DAEMON_INTERVAL"), out daemonInterval); } daemon.Start(daemonInterval); app.UseEndpoints(endpoints => { endpoints.MapControllerRoute("default", "{controller=Home}/{action=Index}"); }); ITetriSettings settings = serviceProvider.GetService <ITetriSettings>(); Console.WriteLine("*********************************************************************"); Console.WriteLine("TETRIFACT SERVER running"); Console.WriteLine(""); Console.WriteLine("Settings:"); Console.WriteLine($"Archive available poll interval: {settings.ArchiveAvailablePollInterval}"); Console.WriteLine($"Archive path: {settings.ArchivePath}"); Console.WriteLine($"Archive wait timeout: {settings.ArchiveWaitTimeout}"); Console.WriteLine($"Authorization level: {settings.AuthorizationLevel}"); Console.WriteLine($"Autocreate archive on package create: {settings.AutoCreateArchiveOnPackageCreate}"); Console.WriteLine($"Cache timeout: {settings.CacheTimeout}"); Console.WriteLine($"Daemon interval: {daemonInterval}"); Console.WriteLine($"Download archive compression: {settings.DownloadArchiveCompression}"); Console.WriteLine($"Index tag list length: {settings.IndexTagListLength}"); Console.WriteLine($"Is storage compression enabled: {settings.IsStorageCompressionEnabled}"); Console.WriteLine($"Link lock wait time: {settings.LinkLockWaitTime}"); Console.WriteLine($"List page size: {settings.ListPageSize}"); Console.WriteLine($"Log path: {logPath}"); Console.WriteLine($"Max archives: {settings.MaxArchives}"); Console.WriteLine($"PackagePath: {settings.PackagePath}"); Console.WriteLine($"Pages per page group: {settings.PagesPerPageGroup}"); Console.WriteLine($"Repository path: {settings.RepositoryPath}"); Console.WriteLine($"Space safety threshold: {settings.SpaceSafetyThreshold}"); Console.WriteLine($"Tags path: {settings.TagsPath}"); Console.WriteLine($"Temp path: {settings.TempPath}"); Console.WriteLine("*********************************************************************"); }
public Workspace(ITetriSettings settings, ILogger <IWorkspace> log, IHashService hashService) { _settings = settings; _log = log; _hashService = hashService; }
public RepositoryCleaner(IIndexReader indexReader, ITetriSettings settings, ILogger <IRepositoryCleaner> logger) { _settings = settings; _logger = logger; _indexReader = indexReader; }
public ReadLevel(ITetriSettings settings) { _settings = settings; }