public static FileServicesOptions AddFileStore(this FileServicesOptions app, FileStorage.IFileStore fileStore)
{
return(AddFileStore(app, sp =>
{
return fileStore;
}));
}
/// <summary>
/// Writes the <paramref name="source"/> instance, of type <typeparamref name="T"/>, as binary data to the file with the given <paramref name="rootFilename"/> in the specified <paramref name="fileStore"/>.
/// </summary>
/// <typeparam name="T">The <see cref="Type"/> of the instance.</typeparam>
/// <param name="source">The instance to save.</param>
/// <param name="fileStore">The <see cref="FileStorage.IFileStore"/> to save the file into.</param>
/// <param name="rootFilename">The name of the file to save the binary data to.</param>
public void Save <T>(T source, FileStorage.IFileStore fileStore, string rootFilename)
{
// check for errors
if (string.IsNullOrWhiteSpace(rootFilename))
{
throw new ArgumentNullException(nameof(rootFilename));
}
if (fileStore == null)
{
throw new ArgumentNullException(nameof(fileStore));
}
// save T to file
var tempFilename = System.IO.Path.GetTempFileName();
try
{
// save file to temp file
Save(source, tempFilename, true);
// add temp file to file store
var fileInfo = new System.IO.FileInfo(tempFilename);
fileStore.Add(rootFilename, tempFilename, fileInfo.LastWriteTimeUtc, fileInfo.Length);
fileStore.Save(false);
}
finally
{
// delete temp file
if (System.IO.File.Exists(tempFilename))
{
System.IO.File.Delete(tempFilename);
}
}
}
private IPackageConfiguration ExtractAndReadConfiguration(FileStorage.IFileStore fileStore,
Configuration.IConfigurationSerializer <StringBuilder> serializer,
string filename)
{
if (!fileStore.Contains(filename))
{
return(null);
}
var extractedFilename = fileStore.Get(filename).Extract(System.IO.Path.GetTempPath(), true);
if (!System.IO.File.Exists(extractedFilename))
{
return(null);
}
try
{
var config = serializer.Deserialize(new StringBuilder(System.IO.File.ReadAllText(extractedFilename)));
return((IPackageConfiguration)Core.Configuration.ConfigurationHelper.InstantiateTypeFromConfigurationGroup(typeof(PackageConfiguration), config));
}
catch
{
// swallow any exception; return null
return(null);
}
finally
{
FileStorage.FileStorageHelper.DeleteFile(extractedFilename);
}
}
public LogControllerThreadWorker(LogMarshal logMarshal,
LogControllerSettings logSettings,
Logging.ILogStatistics logStats,
FileStorage.IFileStore archiveFileStore,
IArchiveFilenameFactory archiveFilenameFactory)
{
_LogMarshal = logMarshal;
_LogSettings = logSettings;
_LogStats = logStats;
_ArchiveFileStore = archiveFileStore;
_ArchiveFilenameFactory = archiveFilenameFactory;
}
/// <summary>
/// Will copy all logs, which returns <b>true</b> from the <paramref name="logEntryFilterPredicate"/> function, from the <paramref name="log"/> and write them to a text file with the <paramref name="filename"/> in the given <paramref name="fileStore"/>.
/// </summary>
/// <remarks>
/// <code>
/// // The following characters are encoded into, and decoded from, the following:
/// // Percent (%) %<25>
/// // Semicolon (;) %<3B>
/// // Double-Quote (") %<22>
/// // Newline ( ) %<0D>
/// </code>
/// </remarks>
/// <param name="log">The logger to read log from.</param>
/// <param name="fileStore">The file store to write the log file to.</param>
/// <param name="filename">The name of the file in the file store to write the logs to.</param>
/// <param name="writeLogEntriesUsingLocalTime">Sets whether the date is written to the log relative to UTC or the local computer's timezone.</param>
/// <param name="logEntryFilterPredicate">The <see cref="Func{T, TResult}"/> should return <b>true</b> to write the log to the archive file; return <b>false</b> to skip writing the log.</param>
/// <returns>The number of logs written to the log file.</returns>
public static int ArchiveLogs(ILogReader log,
FileStorage.IFileStore fileStore,
string filename,
bool writeLogEntriesUsingLocalTime,
Func <ILogEntry, bool> logEntryFilterPredicate)
{
return(ArchiveLogs(log,
fileStore,
filename,
writeLogEntriesUsingLocalTime,
false,
0,
0,
logEntryFilterPredicate));
}
/// <summary>
/// Instantiates a new <see cref="PackageProvider"/> .
/// </summary>
/// <param name="packagesFileStore">The file store containing the package files.</param>
/// <param name="configurationFilename">The filename of the configuration file in the packages.</param>
/// <param name="configurationSerializer">The configuration serializer to use to serialize and deserialize configuration files.</param>
/// <param name="packageFileStoreProvider">A file store provider which facilitates creating and connecting to packages.</param>
public PackageProvider(FileStorage.IFileStore packagesFileStore,
string configurationFilename,
Configuration.IConfigurationSerializer <StringBuilder> configurationSerializer,
IPackageFileStoreProvider packageFileStoreProvider)
: this()
{
_AllPackagesFileStore = packagesFileStore ?? throw new ArgumentNullException(nameof(packagesFileStore));
if (string.IsNullOrWhiteSpace(configurationFilename))
{
throw new ArgumentNullException(nameof(configurationFilename));
}
_ConfigurationFilename = configurationFilename;
_ConfigurationSerializer = configurationSerializer ?? throw new ArgumentNullException(nameof(configurationSerializer));
PackageFileStoreProvider = packageFileStoreProvider ?? throw new ArgumentNullException(nameof(packageFileStoreProvider));
}
/// <summary>
/// Will copy all logs from the <paramref name="log"/> and write them to a text file with the <paramref name="filename"/> in the given <paramref name="fileStore"/>.
/// </summary>
/// <remarks>
/// <code>
/// // The following characters are encoded into, and decoded from, the following:
/// // Percent (%) %<25>
/// // Semicolon (;) %<3B>
/// // Double-Quote (") %<22>
/// // Newline ( ) %<0D>
/// </code>
/// </remarks>
/// <param name="log">The logger to read log from.</param>
/// <param name="fileStore">The file store to write the log file to.</param>
/// <param name="filename">The name of the file in the file store to write the logs to.</param>
/// <param name="writeLogEntriesUsingLocalTime">Sets whether the date is written to the log relative to UTC or the local computer's timezone.</param>
/// <param name="truncateLogArchive">Sets whether the <paramref name="fileStore"/> will be automatically truncated.</param>
/// <param name="truncateLogArchiveMaximumFiles">The total number of files allowed in the <paramref name="fileStore"/> before auto truncation is performed.</param>
/// <param name="truncateLogArchivePercentageToRemove">The percentage of log archive files to remove once <paramref name="truncateLogArchiveMaximumFiles"/> has been exceeded.</param>
/// <returns>The number of logs written to the log file.</returns>
public static int ArchiveLogs(ILogReader log,
FileStorage.IFileStore fileStore,
string filename,
bool writeLogEntriesUsingLocalTime,
bool truncateLogArchive,
int truncateLogArchiveMaximumFiles,
double truncateLogArchivePercentageToRemove)
{
return(ArchiveLogs(log,
fileStore,
filename,
writeLogEntriesUsingLocalTime,
truncateLogArchive,
truncateLogArchiveMaximumFiles,
truncateLogArchivePercentageToRemove,
new Func <ILogEntry, bool>((e) => { return true; })));
}
/// <summary>
/// Will remove files from the <paramref name="fileStore"/> based on the parameters given.
/// </summary>
/// <param name="fileStore">The <paramref name="fileStore"/> to remove files from.</param>
/// <param name="truncateLogArchiveMaximumFiles">The maximum files allowed to remain in the <paramref name="fileStore"/>.</param>
/// <param name="truncateLogArchivePercentageToRemove">The percentage of files to remove from the <paramref name="fileStore"/>.</param>
private static void TruncateArchiveFileStore(FileStorage.IFileStore fileStore, int truncateLogArchiveMaximumFiles, double truncateLogArchivePercentageToRemove)
{
if (fileStore.Count >= truncateLogArchiveMaximumFiles)
{
var removeCount = (int)(fileStore.Count * truncateLogArchivePercentageToRemove);
if (removeCount > 0)
{
foreach (var item in from x in fileStore.GetAll()
orderby x.RootFileLastModifiedTimeUtc ascending
select x)
{
fileStore.Delete(item.RootFilename);
if (--removeCount <= 0)
{
break;
}
}
}
}
}
/// <summary>
/// Instantiates a new <see cref="LogController"/>.
/// </summary>
/// <param name="log">The <see cref="Logging.ILog"/>-based logger used to write the actual logs.</param>
/// <param name="logArchiveFileStore">A <see cref="FileStorage.IFileStore"/> when log archives will be created.</param>
/// <param name="archiveFilenameFactory">A <see cref="IArchiveFilenameFactory"/> used to create archive log file names.</param>
/// <param name="logControllerSettings">Settings to control the actions of the <see cref="ILogController"/>.</param>
public LogController(Logging.ILog log,
FileStorage.IFileStore logArchiveFileStore,
IArchiveFilenameFactory archiveFilenameFactory,
LogControllerSettings logControllerSettings)
: this()
{
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
// **** turn OFF auto-truncation if it is the known interface:{Logging.ITruncatable}
if (log is Logging.ITruncatable)
{
(log as Logging.ITruncatable).AutoTruncateEnabled = false;
}
//
_Log = log;
Settings = logControllerSettings ?? throw new ArgumentNullException(nameof(logControllerSettings));
_LogArchiveFileStore = logArchiveFileStore ?? throw new ArgumentNullException(nameof(logArchiveFileStore));
_ArchiveFilenameFactory = archiveFilenameFactory ?? throw new ArgumentNullException(nameof(archiveFilenameFactory));
}
/// <summary>
/// Instantiates a new connected package.
/// </summary>
/// <param name="packagesStore">The file store containing the package.</param>
/// <param name="packageRootFilename">The package file name in the file store.</param>
/// <param name="originalFilename">The file name for the package file store.</param>
/// <param name="packFileStore">A file store connected to the package file store.</param>
/// <param name="packConfiguration">The package configuration read from this package.</param>
internal ConnectedPackage(FileStorage.IFileStore packagesStore,
string packageRootFilename,
string originalFilename,
FileStorage.IFileStore packFileStore,
IPackageConfiguration packConfiguration)
: this()
{
_PackagesStore = packagesStore ?? throw new ArgumentNullException(nameof(packagesStore));
if (string.IsNullOrWhiteSpace(packageRootFilename))
{
throw new ArgumentNullException(nameof(packageRootFilename));
}
_PackageRootFilename = packageRootFilename;
if (string.IsNullOrWhiteSpace(originalFilename))
{
throw new ArgumentNullException(nameof(originalFilename));
}
_OriginalFilename = originalFilename;
_FileStore = packFileStore ?? throw new ArgumentNullException(nameof(packFileStore));
PackageConfiguration = packConfiguration ?? throw new ArgumentNullException(nameof(packConfiguration));
}
/// <summary>
/// Reads the contents of the file, specified by the <paramref name="rootFilename"/>, from the <paramref name="fileStore"/> and converts it from binary data into an instance of type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type to convert the contents of the <paramref name="rootFilename"/> into.</typeparam>
/// <param name="rootFilename">The name of the file to convert.</param>
/// <param name="fileStore">The <see cref="FileStorage.IFileStore"/> to read the file from.</param>
/// <returns>The contents of the file, specified by the <paramref name="rootFilename"/>, from the <paramref name="fileStore"/> and converted from binary data into an instance of type <typeparamref name="T"/>.</returns>
public T Load <T>(string rootFilename, FileStorage.IFileStore fileStore)
{
// check for errors
if (string.IsNullOrWhiteSpace(rootFilename))
{
throw new ArgumentNullException(nameof(rootFilename));
}
if (fileStore == null)
{
throw new ArgumentNullException(nameof(fileStore));
}
if (!fileStore.Contains(rootFilename))
{
throw new System.IO.FileNotFoundException(string.Format("File not found. Filename={0}", rootFilename), rootFilename);
}
//
var results = default(T);
var fileStoreItem = fileStore.Get(rootFilename);
var extractedFile = "";
if (fileStoreItem != null)
{
try
{
extractedFile = fileStore.Extract(System.IO.Path.GetTempPath(), fileStoreItem, true);
results = Load <T>(extractedFile);
}
finally
{
// delete temp file
if (System.IO.File.Exists(extractedFile))
{
System.IO.File.Delete(extractedFile);
}
}
}
return(results);
}
/// <summary>
/// Initializes an instance of the ArchivedLogs using the <paramref name="archiveFileStore"/> as the source of log files.
/// </summary>
/// <param name="archiveFileStore">The file store which provides the log files.</param>
public ArchivedLogs(FileStorage.IFileStore archiveFileStore)
: this()
{
ArchiveFileStore = archiveFileStore ?? throw new ArgumentNullException(nameof(archiveFileStore));
}
/// <summary>
/// Will copy all logs, which returns <b>true</b> from the <paramref name="logEntryFilterPredicate"/> function, from the <paramref name="log"/> and write them to a text file with the <paramref name="filename"/> in the given <paramref name="fileStore"/>.
/// </summary>
/// <remarks>
/// <code>
/// // The following characters are encoded into, and decoded from, the following:
/// // Percent (%) %<25>
/// // Semicolon (;) %<3B>
/// // Double-Quote (") %<22>
/// // Newline ( ) %<0D>
/// </code>
/// </remarks>
/// <param name="log">The logger to read log from.</param>
/// <param name="fileStore">The file store to write the log file to.</param>
/// <param name="filename">The name of the file in the file store to write the logs to.</param>
/// <param name="writeLogEntriesUsingLocalTime">Sets whether the date is written to the log relative to UTC or the local computer's timezone.</param>
/// <param name="truncateLogArchive">Sets whether the <paramref name="fileStore"/> will be automatically truncated.</param>
/// <param name="truncateLogArchiveMaximumFiles">The total number of files allowed in the <paramref name="fileStore"/> before auto truncation is performed.</param>
/// <param name="truncateLogArchivePercentageToRemove">The percentage of log archive files to remove once <paramref name="truncateLogArchiveMaximumFiles"/> has been exceeded.</param>
/// <param name="logEntryFilterPredicate">The <see cref="Func{T, TResult}"/> should return <b>true</b> to write the log to the archive file; return <b>false</b> to skip writing the log.</param>
/// <returns>The number of logs written to the log file.</returns>
public static int ArchiveLogs(ILogReader log,
FileStorage.IFileStore fileStore,
string filename,
bool writeLogEntriesUsingLocalTime,
bool truncateLogArchive,
int truncateLogArchiveMaximumFiles,
double truncateLogArchivePercentageToRemove,
Func <ILogEntry, bool> logEntryFilterPredicate)
{
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
if (fileStore == null)
{
throw new ArgumentNullException(nameof(fileStore));
}
if (string.IsNullOrWhiteSpace(filename))
{
throw new ArgumentNullException(nameof(filename));
}
if ((truncateLogArchivePercentageToRemove < 0) || (truncateLogArchivePercentageToRemove > 1))
{
throw new ArgumentOutOfRangeException(nameof(truncateLogArchivePercentageToRemove), $"Parameter truncateLogArchivePercentageToRemove must be between 0.0 and 1.0. Value={truncateLogArchivePercentageToRemove}");
}
if (logEntryFilterPredicate == null)
{
throw new ArgumentNullException(nameof(logEntryFilterPredicate));
}
//
var archivedLogs = 0;
// copy logs from the logger to the temp file
var tempFilename = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString());
lock (log.SyncObject)
{
using (var sw = new System.IO.StreamWriter(tempFilename, false))
{
foreach (var entry in from x in log.Read()
orderby x.Timestamp ascending
select x)
{
if ((entry != null) && (logEntryFilterPredicate(entry)))
{
sw.WriteLine(FormatLogLine(entry, writeLogEntriesUsingLocalTime));
++archivedLogs;
}
}
}
}
if (archivedLogs > 0)
{
// copy temp file into FileStore
fileStore.Add(filename, tempFilename, DateTime.UtcNow, 0);
if (truncateLogArchive)
{
TruncateArchiveFileStore(fileStore, truncateLogArchiveMaximumFiles, truncateLogArchivePercentageToRemove);
}
fileStore.Save(true);
}
// delete temp file
System.IO.File.Delete(tempFilename);
// return number of archived logs
return(archivedLogs);
}
public FileManagerController(//IFileManagerProvider fileManager,
FileStorage.IFileStore fileStore)
{
//this._fileManager = fileManager;
this._fileStore = fileStore;
}
private IPackageConfiguration RetrieveConfiguration(FileStorage.IFileStore packageStore, string configurationFilename) => ExtractAndReadConfiguration(packageStore, _ConfigurationSerializer, configurationFilename);