Exemplo n.º 1
0
        /// <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);
        }
Exemplo n.º 2
0
        /// <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;
        }
Exemplo n.º 3
0
 /// <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)
 {
 }
Exemplo n.º 4
0
        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;
 }