Пример #1
0
        static void Main(string[] args)
        {
            Console.WriteLine(args[0]);
            String CD = Directory.GetCurrentDirectory();

            String[] fs = args[0].Split(';');
            foreach (string dir in fs)
            {
                FS       tln = new FS();
                string[] d   = dir.Split('=');
                tln.TLD = Path.Combine(CD, d[0]);
                if (d.Length == 2)
                {
                    tln.P = fromstr(d[1]);
                }
                else
                {
                    tln.P = RWPerm.RO;
                }
                Console.WriteLine(tln.P.ToString());
                lfs.Add(tln);
            }
            WinUnion     wu  = new WinUnion(lfs);
            DokanOptions opt = DokanOptions.DebugMode;

            Dokan.Mount(wu, args[1], opt, new NullLogger());
        }
Пример #2
0
        private static void Main(string[] args)
        {
            var unmountOptions = new UnmountOptions();

            if (CommandLine.Parser.Default.ParseArguments(args, unmountOptions))
            {
                Dokan.RemoveMountPoint(unmountOptions.UnmountDirectory);
                return;
            }

            var options = new Options();

            if (CommandLine.Parser.Default.ParseArguments(args, options))
            {
                try
                {
                    ArchiveManager archiveManager = new ArchiveManager(options.PboDirectories);
                    PboFSTree      fileTree       = new PboFSTree(archiveManager);
                    PboFS          pboFS          = new PboFS(fileTree, archiveManager, options.Prefix);
                    pboFS.Mount(options.MountDirectory, Program.MOUNT_OPTIONS);
                    Console.WriteLine("Success");
                }
                catch (DokanException ex)
                {
                    Console.WriteLine("Error: " + ex.Message);
                }
            }
        }
Пример #3
0
        private static void OnCommonFileSystemWatcherCreated(object sender, FileSystemEventArgs e)
        {
            var fullPath    = AlterPathToMountPath(e.FullPath);
            var isDirectory = Directory.Exists(fullPath);

            Dokan.DokanNotifyCreate(fullPath, isDirectory);
        }
Пример #4
0
        public void Mount(string drive, string apiUrl, bool debugging)
        {
            if (apiUrl != null && apiUrl.Length > 0)
            {
                IpfsClient.DefaultApiUri = new Uri(apiUrl);
            }

            // Verify that the local IPFS service is up and running
            var x = new IpfsClient().IdAsync().Result;

            // CTRL-C will dismount and then exit.
            Console.CancelKeyPress += (s, e) =>
            {
                Console.WriteLine("shutting down...");
                Unmount(drive);
                e.Cancel = true;
            };

            // Mount IPFS, doesn't return until the drive is dismounted
            var options = DokanOptions.WriteProtection;

            if (debugging)
            {
                options |= DokanOptions.DebugMode;
            }
            Dokan.Mount(new IpfsDokan(), drive, options, new DokanLogger());
        }
Пример #5
0
        public static void Main()
        {
            string basePath    = Dir(@"c:\projects\Testing\test\Base");
            string minePath    = Dir(@"c:\projects\Testing\test\Mine");
            string workingPath = Dir(@"c:\projects\Testing\test\Working");

            DokanOperations mirror = new DokanOperations(basePath, minePath);

            Task.Factory.StartNew(() => { mirror.Mount(workingPath, DokanOptions.DebugMode | DokanOptions.EnableNotificationAPI, 1, new NullLogger()); });

            Console.WriteLine(@"Mounted");

            string line;

            do
            {
                line = Console.ReadLine();
                Console.Clear();
            } while (line != "q");

            Dokan.RemoveMountPoint(workingPath);
            Directory.Delete(workingPath);
            Console.WriteLine(@"Success");

            //MainAsync().Wait();
            //Console.WriteLine(@"DONE");
            //Console.ReadLine();
        }
Пример #6
0
 private void unmountBtn_Click(object sender, EventArgs e)
 {
     unmountBtn.Enabled = false;
     SetFUSEStatus("Unmounting...", Color.Orange);
     Dokan.Unmount(DriveLetter);
     SetFUSEStatus("Unmounted.", Color.Red);
 }
Пример #7
0
        public void UnmountVFS()
        {
            if (_dokanTask != null)
            {
                try
                {
                    log.Info($"Unmounting virtual filesystem at {_mountPoint}...");
                    Dokan.RemoveMountPoint(_mountPoint);
                    if (_dokanTask.Wait(TimeSpan.FromSeconds(10)))
                    {
                        log.Info($"Unmount of {_mountPoint} was successful.");
                    }

                    if (_cleanupMountDirOnExit)
                    {
                        Directory.Delete(_mountPoint);
                        log.Info($"Mountpoint directory {_mountPoint} removed.");
                    }
                }
                catch (Exception e)
                {
                    log.Error("Unmount failed: " + e.Message);
                }
                finally
                {
                    _dokanTask = null;
                }
            }
        }
Пример #8
0
        public void Unmount()
        {
            if (this._threadCancel != null)
            {
                this._threadCancel.Cancel();
            }
            if (this._pauseEvent != null)
            {
                this._pauseEvent.Set();
            }

            Debug.WriteLine("Unmount");

            Status = DriveStatus.Unmounting;
            try
            {
                Dokan.RemoveMountPoint(String.Format("{0}:\\", mountedLetter));
            }
            catch
            {
                //Status = DriveStatus.Unmounted;
                //  OnStatusChanged(EventArgs.Empty);
            }
            finally
            {
                _filesystem = null;
            }
        }
Пример #9
0
        public void Unmount()
        {
            if (this.reconnectThread != Thread.CurrentThread)
            {
                this.stopReconnect();
            }

            if (_threadCancel != null)
            {
                _threadCancel.Cancel();
            }
            if (_pauseEvent != null)
            {
                _pauseEvent.Set();
            }

            Debug.WriteLine("Unmount");
            Status = DriveStatus.Unmounting;
            try
            {
                Dokan.RemoveMountPoint($"{Letter}:\\");
                _filesystem?.Dispose();
            }
            catch
            {
                //Status = DriveStatus.Unmounted;
                //  OnStatusChanged(EventArgs.Empty);
            }
            finally
            {
                _filesystem = null;
                Status      = DriveStatus.Unmounted;
                OnStatusChanged(EventArgs.Empty);
            }
        }
Пример #10
0
        public bool Stop(HostControl hostControl)
        {
            Runners.Cancel();
            Globals.NotificationCenter.InvokeAsync(x => x.OnServiceStopped());

            foreach (var volume in Globals.Database.Table <DiskModel>().ToList())
            {
                try
                {
                    var mountPoint = Globals.Database.GetMountPoint(volume.Id);
                    Dokan.RemoveMountPoint(mountPoint);
                    if (Globals.Volumes.TryRemove(volume.Id, out var thread))
                    {
                        thread.Dispose();
                    }
                }
                catch
                {
                    // Ignored. Terminating.
                }
            }

            Globals.CloudService.Dispose();
            Globals.Database.Dispose();

            Logger.LogInformation("Windows service stopped.");

            return(true);
        }
Пример #11
0
        public void Dispose()
        {
            Debug.WriteLine("Dispose");

            _threadCancel?.Cancel();
            _pauseEvent?.Set();

            try
            {
                Dokan.RemoveMountPoint($"{Letter}:\\");
                if (_filesystem != null)
                {
                    _filesystem.Dispose();
                    _filesystem = null;
                }
            }
            catch
            {
                if (Status != DriveStatus.Unmounted)
                {
                    Status = DriveStatus.Unmounted;
                }
            }
            finally
            {
                _filesystem = null;
            }

            _mountCancel?.Dispose();
            _threadCancel?.Dispose();
            _pauseEvent?.Dispose();
        }
Пример #12
0
        private static void Monitor_DeviceDisconnected(object sender, DeviceDataEventArgs e)
        {
            Log.Information("Device disconnected", e.Device);
            List <VirtualDrive> drivesToRemove = new List <VirtualDrive>();

            foreach (VirtualDrive d in Devices)
            {
                if (e.Device.Serial.Equals(d.AndroidDevice.Serial))
                {
                    if (Dokan.Unmount(d.DriveLetter))
                    {
                        Log.Information("Successfully unmounted drive " + d.DriveLetter);
                    }
                    else
                    {
                        Log.Warning("Error while unmounting " + d.DriveLetter);
                    }
                    drivesToRemove.Add(d);
                }
            }
            foreach (VirtualDrive d in drivesToRemove)
            {
                Devices.Remove(d);
            }
        }
Пример #13
0
 public static void Mount(MountableFileSystem fs)
 {
     if (CanMount())
     {
         char   drive  = GetAvailableDriveLetter();
         Thread thread = new Thread(new ThreadStart(() =>
         {
             DokanOptions options = DokanOptions.RemovableDrive;
             if (fs.Mode != OpenMode.ReadWrite)
             {
                 options |= DokanOptions.WriteProtection;
             }
             Dokan.Mount(fs, $"{drive}:", options);
         }
                                                    ));
         if (Mounted.ContainsKey(fs))
         {
             Unmount(fs);
         }
         thread.Start();
         Mounted[fs] = new Tuple <Thread, char>(thread, drive);
     }
     else
     {
         MessageBox.Show("Dokan driver seems to be missing. Install the driver and try again.");
     }
 }
Пример #14
0
        private static void Main(string[] args)
        {
            try
            {
                if (args.Length != 2)
                {
                    Console.WriteLine(@"usage: mountbck.exe S 'C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\MSSQL\Backup\AdventureWorks2014.bak'");
                    Console.WriteLine("Press any key for exit.");
                    Console.ReadKey();
                    return;
                }

                var driveLetter    = args[0][0];
                var backupFileName = args[1];

                Dokan.Unmount(driveLetter);
                var backupVfs = new SqlBackupVfs(backupFileName, driveLetter);
                backupVfs.Mount($"{driveLetter}:\\", DokanOptions.NetworkDrive, 1);

                Console.WriteLine("Success");
            }
            catch (DokanException ex)
            {
                Console.WriteLine("Error: " + ex.Message);
            }
        }
Пример #15
0
        public void Dispose()
        {
            Debug.WriteLine("Dispose");


            if (_threadCancel != null) _threadCancel.Cancel();
            if (_pauseEvent != null) _pauseEvent.Set();
            try
            {
                Dokan.RemoveMountPoint(String.Format("{0}:\\", Letter));
                if (_filesystem != null)
                {
                    _filesystem.Dispose();


                    _filesystem = null;
                }
            }
            catch
            {
                Status = DriveStatus.Unmounted;
            }
            finally
            {
                _filesystem = null;
            }


            if (_mountCancel != null) {_mountCancel.Dispose();}
            if (_threadCancel != null) {_threadCancel.Dispose();}
            if (_pauseEvent != null) {_pauseEvent.Dispose();}
        }
Пример #16
0
        public void Unmount()
        {
            Debug.WriteLine("Unmount");

            Status = DriveStatus.Unmounting;
            try
            {
               // Dokan.Unmount(Letter);
                Dokan.RemoveMountPoint(String.Format("{0}:\\", Letter));
                if (_filesystem != null)
                {

                    _filesystem.Dispose();


                   
                }
            }
            catch
            {
                //Status = DriveStatus.Unmounted;
                //  OnStatusChanged(EventArgs.Empty);
            }
            finally
            {
                _filesystem = null;  
            }

        }
Пример #17
0
        public static void AssemblyInitialize(TestContext context)
        {
            var dokanOptions = DokanOptions.DebugMode | DokanOptions.MountManager | DokanOptions.CurrentSession;

#if NETWORK_DRIVE
            dokanOptions |= DokanOptions.NetworkDrive;
#else
            dokanOptions |= DokanOptions.RemovableDrive;
#endif
#if USER_MODE_LOCK
            dokanOptions |= DokanOptions.UserModeLock;
#endif

            Dokan.Init();
            safeMount   = DokanOperationsFixture.Operations.CreateFileSystem(DokanOperationsFixture.NormalMountPoint, dokanOptions);
            unsafeMount = DokanOperationsFixture.UnsafeOperations.CreateFileSystem(DokanOperationsFixture.UnsafeMountPoint, dokanOptions);
            var drive  = new DriveInfo(DokanOperationsFixture.NormalMountPoint);
            var drive2 = new DriveInfo(DokanOperationsFixture.UnsafeMountPoint);
            while (!drive.IsReady || !drive2.IsReady)
            {
                Thread.Sleep(50);
            }
            while (DokanOperationsFixture.HasPendingFiles)
            {
                Thread.Sleep(50);
            }
        }
Пример #18
0
 public Task StopAsync(CancellationToken cancellationToken)
 {
     if (!Dokan.RemoveMountPoint(_commandLineArguments.MountPoint))
     {
         _logger.Fatal("Can't unmount {MountPoint}", _commandLineArguments.MountPoint);
     }
     return(Task.CompletedTask);
 }
Пример #19
0
        public static void Unmount(MountableFileSystem fs)
        {
            Dokan.Unmount(Mounted[fs].Item2);
            string mountPoint = $"{Mounted[fs].Item2}:";

            Mounted[fs].Item1.Join(); // wait for thread to actually stop
            Dokan.RemoveMountPoint(mountPoint);
        }
Пример #20
0
 public static void AssemblyCleanup()
 {
     mounterThread.Abort();
     mounterThread2.Abort();
     Dokan.Unmount(DokanOperationsFixture.NormalMountPoint[0]);
     Dokan.Unmount(DokanOperationsFixture.UnsafeMountPoint[0]);
     Dokan.RemoveMountPoint(DokanOperationsFixture.NormalMountPoint);
     Dokan.RemoveMountPoint(DokanOperationsFixture.UnsafeMountPoint);
 }
Пример #21
0
 public void Stop()
 {
     if (IsRunning)
     {
         FireStateChange(LiquesceSvcState.Unknown, "Stop has been requested");
         int retVal = Dokan.DokanUnmount(mountedDriveLetter);
         Log.Info("Stop returned[{0}]", retVal);
     }
 }
Пример #22
0
        public bool UnMountVirtualDrive()
        {
            if (_mountPoint == null)
            {
                return(false);
            }

            return(Dokan.Unmount(_mountPoint[0]) && Dokan.RemoveMountPoint(_mountPoint));
        }
Пример #23
0
        private static void Main(string[] args)
        {
            SetConsoleCtrlHandler(ConsoleCtrlCheck, true);

            var unmountOptions = new UnmountOptions();

            if (CommandLine.Parser.Default.ParseArguments(args, unmountOptions))
            {
                Dokan.RemoveMountPoint(unmountOptions.UnmountDirectory);
                return;
            }

            var options = new Options();

            if (CommandLine.Parser.Default.ParseArguments(args, options))
            {
                try
                {
                    Console.WriteLine("DokanPbo booting...");

                    if (options.WriteableDirectory == null)
                    {
                        Console.WriteLine("Creating temporary write directory...");
                        options.WriteableDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
                        //#TODO can throw exception and die if it creates a existing folder by accident
                        Directory.CreateDirectory(options.WriteableDirectory);

                        //Need to register handler to catch console exit to delete directory at end
                        SetConsoleCtrlHandler(ConsoleCtrlCheck, true);
                        deleteTempDirOnClose = options.WriteableDirectory;
                    }

                    if (!Directory.Exists(options.WriteableDirectory))
                    {
                        Console.WriteLine("FATAL Writeable Directory doesn't exist: " + options.WriteableDirectory);
                        Console.ReadKey();
                    }

                    ArchiveManager archiveManager = new ArchiveManager(options.PboDirectories);
                    PboFSTree      fileTree       = new PboFSTree(archiveManager, options.WriteableDirectory, options.ExcludePrefix);
                    PboFS          pboFS          = new PboFS(fileTree, archiveManager, options.Prefix);
#if DEBUG
                    ILogger logger = new NullLogger(); //null;
#else
                    ILogger logger = new NullLogger();
#endif
                    Dokan.Init();
                    pboFS.Mount(options.MountDirectory, Program.MOUNT_OPTIONS, true, logger);
                    Console.WriteLine("Success");
                }
                catch (DokanException ex)
                {
                    Console.WriteLine("Error: " + ex.Message);
                }
            }
        }
Пример #24
0
        public void Unmount()
        {
            if (_th != null)
            {
                _th.Abort();
            }

            Dokan.Unmount(this.DriveLetter);
            Dokan.RemoveMountPoint(this.DriveLetter + ":");
        }
Пример #25
0
        public static void startVDrive(char vDriveLetter)
        {
            Dokan.Unmount(vDriveLetter);
            di = new VDrive();
#if DEBUG
            Thread t2 = new Thread(() => { di.Mount(vDriveLetter + ":\\", DokanOptions.DebugMode, 1); });
#else
            Thread t2 = new Thread(() => { di.Mount(vDriveLetter + ":\\", DokanOptions.FixedDrive, 10); });
#endif
            t2.Start();
        }
Пример #26
0
        public virtual void ClearMountPoint()
        {
            if (!IsMounted)
            {
                return;
            }

            Dokan.RemoveMountPoint(this.MountPoint);
            this._isMounted = false;
            OnMountChanged(new connector.MountChangedArgs(_isMounted));
        }
Пример #27
0
        private void startVDriveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Dokan.Unmount(vDriveLetter);
            di = new VDrive();
#if DEBUG
            Thread t2 = new Thread(() => { di.Mount(vDriveLetter + ":\\", DokanOptions.DebugMode, 1); });
#else
            Thread t2 = new Thread(() => { di.Mount(vDriveLetter + ":\\", DokanOptions.FixedDrive, 10); });
#endif
            t2.Start();
        }
Пример #28
0
        public void UnmountAllDrives()
        {
            foreach (var volume in Globals.Database.Table <DiskModel>().ToList())
            {
                var mountPoint = Globals.Database.GetMountPoint(volume.Id);
                try { Dokan.RemoveMountPoint(mountPoint); }
                catch { } // Ignored.
                Globals.Database.RemoveMountPoint(volume.Id);
            }

            Globals.Database.SaveSetting(WindowsUserSettings.EnableVolumeMounting, "0");
        }
Пример #29
0
        private bool _disposedValue; // To detect redundant calls

        private void Dispose(bool disposing)
        {
            if (!_disposedValue)
            {
                if (disposing)
                {
                    Dokan.RemoveMountPoint(Mountpoint.FullName.Trim('\\'));
                }
            }

            _disposedValue = true;
        }
Пример #30
0
 private static bool ConsoleCtrlCheck(CtrlTypes ctrlType)
 {
     if (ctrlType == CtrlTypes.CTRL_CLOSE_EVENT)
     {
         if (deleteTempDirOnClose != null)
         {
             Directory.Delete(deleteTempDirOnClose, true);
         }
         Dokan.Shutdown();
     }
     return(true);
 }