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