/// <summary>
/// Creates instance of this class.
/// </summary>
/// <param name="userFileSystemPath">File or folder path in the user file system.</param>
/// <param name="engine">Engine instance.</param>
/// <param name="logger">Logger.</param>
public VirtualFileSystemItem(string userFileSystemPath, VirtualEngine engine, ILogger logger)
{
if (string.IsNullOrEmpty(userFileSystemPath))
{
throw new ArgumentNullException(nameof(userFileSystemPath));
}
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
Engine = engine ?? throw new ArgumentNullException(nameof(engine));
UserFileSystemPath = userFileSystemPath;
RemoteStoragePath = Mapping.MapPath(userFileSystemPath);
}
/// <summary>
/// Creates instance of this class.
/// </summary>
/// <param name="userFileSystemRootPath">User file system root path.</param>
/// <param name="engine">Engine.</param>
/// <param name="logger">Logger.</param>
internal MsOfficeDocsMonitor(string userFileSystemRootPath, VirtualEngine engine, ILog log)
: base("MS Office docs Monitor", log)
{
if (string.IsNullOrEmpty(userFileSystemRootPath))
{
throw new ArgumentNullException(nameof(userFileSystemRootPath));
}
this.engine = engine ?? throw new ArgumentNullException(nameof(engine));
watcher.IncludeSubdirectories = true;
watcher.Path = userFileSystemRootPath;
//watcher.Filter = "*.*";
watcher.NotifyFilter = NotifyFilters.FileName;
watcher.Error += Error;
watcher.Created += CreatedAsync;
watcher.Changed += ChangedAsync;
watcher.Deleted += DeletedAsync;
watcher.Renamed += RenamedAsync;
}
/// <summary>
/// Creates instance of this class.
/// </summary>
/// <param name="path">File path in the user file system.</param>
/// <param name="engine">Engine instance.</param>
/// <param name="logger">Logger.</param>
public VirtualFile(string path, VirtualEngine engine, ILogger logger) : base(path, engine, logger)
{
}
static async Task Main(string[] args)
{
// Load Settings.
IConfiguration configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json", false, true).Build();
Settings = configuration.ReadSettings();
// Load Log4Net for net configuration.
var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
// Enable UTF8 for Console Window
Console.OutputEncoding = System.Text.Encoding.UTF8;
log.Info($"\n{System.Diagnostics.Process.GetCurrentProcess().ProcessName} {Settings.AppID}");
log.Info("\nPress 'Q' to unregister file system, delete all files/folders and exit (simulate uninstall with full cleanup).");
log.Info("\nPress 'q' to unregister file system and exit (simulate uninstall).");
log.Info("\nPress any other key to exit without unregistering (simulate reboot).");
log.Info("\n----------------------\n");
// Typically you will register sync root during your application installation.
// Here we register it during first program start for the sake of the development convenience.
if (!await Registrar.IsRegisteredAsync(Settings.UserFileSystemRootPath))
{
log.Info($"\nRegistering {Settings.UserFileSystemRootPath} sync root.");
Directory.CreateDirectory(Settings.UserFileSystemRootPath);
Directory.CreateDirectory(Settings.ServerDataFolderPath);
await Registrar.RegisterAsync(SyncRootId, Settings.UserFileSystemRootPath, Settings.ProductName,
Path.Combine(Settings.IconsFolderPath, "Drive.ico"));
}
else
{
log.Info($"\n{Settings.UserFileSystemRootPath} sync root already registered.");
}
// Log indexed state. Indexing must be enabled for the sync root to function.
StorageFolder userFileSystemRootFolder = await StorageFolder.GetFolderFromPathAsync(Settings.UserFileSystemRootPath);
log.Info($"\nIndexed state: {(await userFileSystemRootFolder.GetIndexedStateAsync())}\n");
ConfigureWebDAVClient();
ConsoleKeyInfo exitKey;
// Event to be fired when any key will be pressed in the console or when the tray application exits.
ConsoleManager.ConsoleExitEvent exitEvent = new ConsoleManager.ConsoleExitEvent();
try
{
Engine = new VirtualEngine(
Settings.UserFileSystemLicense,
Settings.UserFileSystemRootPath,
Settings.ServerDataFolderPath,
Settings.IconsFolderPath,
log);
Engine.AutoLock = Settings.AutoLock;
// Start tray application.
Thread tryIconThread = WindowsTrayInterface.CreateTrayInterface(Settings.ProductName, Engine, exitEvent);
// Start processing OS file system calls.
await Engine.StartAsync();
#if DEBUG
// Opens Windows File Manager with user file system folder and remote storage folder.
ShowTestEnvironment();
#endif
// Keep this application running until user input.
ConsoleManager.WaitConsoleReadKey(exitEvent);
// Wait until the "Exit" is pressed or any key in console is pressed to stop application.
exitEvent.WaitOne();
exitKey = exitEvent.KeyInfo;
}
finally
{
Engine.Dispose();
}
if (exitKey.KeyChar == 'q')
{
// Unregister during programm uninstall.
await Registrar.UnregisterAsync(SyncRootId);
log.Info($"\n\nUnregistering {Settings.UserFileSystemRootPath} sync root.");
log.Info("\nAll empty file and folder placeholders are deleted. Hydrated placeholders are converted to regular files / folders.\n");
}
else if (exitKey.KeyChar == 'Q')
{
log.Info($"\n\nUnregistering {Settings.UserFileSystemRootPath} sync root.");
log.Info("\nAll files and folders placeholders are deleted.\n");
// Unregister during programm uninstall and delete all files/folder.
await Registrar.UnregisterAsync(SyncRootId);
try
{
Directory.Delete(Settings.UserFileSystemRootPath, true);
}
catch (Exception ex)
{
log.Error($"\n{ex}");
}
try
{
Directory.Delete(Settings.ServerDataFolderPath, true);
}
catch (Exception ex)
{
log.Error($"\n{ex}");
}
}
else
{
log.Info("\n\nAll downloaded file / folder placeholders remain in file system. Restart the application to continue managing files.\n");
}
}
/// <summary>
/// Creates instance of this class.
/// </summary>
/// <param name="remoteStorageRootPath">Remote storage path. Folder that contains source files to monitor changes.</param>
/// <param name="engine">Engine to send notifications about changes in the remote storage.</param>
/// <param name="log">Logger.</param>
internal RemoteStorageMonitor(string remoteStorageRootPath, VirtualEngine engine, ILog log) : base("Remote Storage Monitor", log)
{
this.remoteStorageRootPath = remoteStorageRootPath;
this.engine = engine;
}