public void ReleaseLock_Unlocked_LockFileDoesNotExist() { SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests"); fileLock.ReleaseLock(); Assert.That(File.Exists(LockPath), Is.False); }
static void Main(string[] args) { var process = Process.GetCurrentProcess(); var fileLock = SimpleFileLock.Create(LockName, LockTimeout); for (var i = 0; i < 20; i++) { Console.WriteLine("{0}: PID {1} attempting to acquire FileLock {2} (attempt {3}", DateTime.Now, process.Id, fileLock.LockName, i); var acquired = fileLock.TryAcquireLock(); if (acquired) { Console.WriteLine("{0}: PID {1} ACQUIRED FileLock {2} - releasing", DateTime.Now, process.Id, fileLock.LockName); fileLock.ReleaseLock(); Console.WriteLine("{0}: PID {1} RELEASED FileLock {2} - releasing", DateTime.Now, process.Id, fileLock.LockName); Console.WriteLine("{0}: PID {1} EXITING", DateTime.Now, process.Id); return; } else { Console.WriteLine("{0}: PID {1} UNABLE TO ACQUIRE FileLock {2} - sleeping", DateTime.Now, process.Id, fileLock.LockName); Thread.Sleep(TimeSpan.FromSeconds(1)); } } }
private void EventWatcher_Load(object sender, EventArgs e) { notifyIcon1.Icon = Constants.DEFAULT_ICON; // onLoad if (runMode == RUN_MODE.MONITOR) { // Set up pidfile to enforce a single instance of the monitor var fileLock = SimpleFileLock.Create(Constants.PIDLOCK_PATH); if (!fileLock.TryAcquireLock()) { Close(); // Another instance of this program is already running on the machine (silent exit) return; } SystemEvents.PowerModeChanged += OnPowerChange; this.FormClosed += EventWatcher_FormClosed; // Run it now DoWork(); } else if (runMode == RUN_MODE.ONCE) { // Run it now DoWork(); Close(); } }
public void TryAcquireLock_Unlocked_ReturnsTrue() { SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests"); Assert.That(fileLock.TryAcquireLock(), Is.True); fileLock.ReleaseLock(); }
public void ReleaseLock_HasLock_LockFileDoesNotExist() { SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests"); Assert.That(fileLock.TryAcquireLock(), Is.True); fileLock.ReleaseLock(); Assert.That(File.Exists(LockPath), Is.False); }
public void TryAcquireLock_OldEmptyFileLock_ReturnsTrue() { File.WriteAllText(LockPath, ""); SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests"); Assert.That(fileLock.TryAcquireLock(), Is.True); fileLock.ReleaseLock(); }
/// <summary> /// Releases the token when client is finished with it /// /// Even though it is a very good idea to release the token when finished with it, /// in the event of a crash, the file is released anyway meaning another application can get it. /// </summary> public static void ReleaseToken() { if (s_fileLock != null) { s_fileLock.ReleaseLock(); s_fileLock = null; } }
public void TryAcquireLock_LockFileCurrentlyOpen_ReturnsFalse() { SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests"); using (File.Open(LockPath, FileMode.Create)) { Assert.That(fileLock.TryAcquireLock(), Is.False); } }
public void ReleaseLock_LockFileCurrentlyOpen_LockFileExists() { SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests"); using (File.Open(LockPath, FileMode.Create)) { fileLock.ReleaseLock(); } Assert.That(File.Exists(LockPath), Is.True); }
public void TryAcquireLock_LockedByActiveProcess_ReturnsFalse() { LockIO.WriteLock(LockPath, new FileLockContent { PID = ActiveProcessId, ProcessName = GetSafeActiveProcessName(), Timestamp = DateTime.Now.Ticks }); SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests"); Assert.That(fileLock.TryAcquireLock(), Is.False); }
public void TryAcquireLock_LockedByActiveProcessTimedOut_ReturnsTrue() { LockIO.WriteLock(LockPath, new FileLockContent { PID = ActiveProcessId, ProcessName = GetSafeActiveProcessName(), Timestamp = (DateTime.Now - TimeSpan.FromHours(2)).Ticks }); SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests", TimeSpan.FromHours(1)); Assert.That(fileLock.TryAcquireLock(), Is.True); }
public void ReleaseLock_LockedByActiveProcess_LockFileExists() { LockIO.WriteLock(LockPath, new FileLockContent { PID = ActiveProcessId, ProcessName = GetSafeActiveProcessName(), Timestamp = DateTime.Now.Ticks }); SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests"); fileLock.ReleaseLock(); Assert.That(File.Exists(LockPath), Is.True); }
/// <summary> /// Try to acquire the token quietly /// </summary> /// <param name="uniqueIdentifier"></param> /// <returns>True if we successfully acquired the token, false otherwise</returns> public static bool AcquireTokenQuietly(string uniqueIdentifier) { Guard.AgainstNull(uniqueIdentifier, "uniqueIdentifier"); // Each process may only acquire one token if (s_fileLock != null) { return(false); } s_fileLock = SimpleFileLock.Create(uniqueIdentifier + FileExtension); return(s_fileLock.TryAcquireLock()); }
public void TryAcquireLock_LockedByDeadProcess_ReturnsTrue() { LockIO.WriteLock(LockPath, new FileLockContent { PID = 9999, ProcessName = Path.GetRandomFileName(), Timestamp = DateTime.Now.Ticks }); SimpleFileLock fileLock = SimpleFileLock.Create("SimpleFileLockTests"); Assert.That(fileLock.TryAcquireLock(), Is.True); fileLock.ReleaseLock(); }
static void Main(string[] args) { Console.WriteLine("Starting"); var lockFolder = args[0]; var path = System.IO.Path.Combine(lockFolder, "file.lock"); var fileLock = SimpleFileLock.Create(path, TimeSpan.FromMinutes(1)); Console.WriteLine("Lock Initialised"); var cts = new CancellationTokenSource(); cts.CancelAfter(new TimeSpan(0, 1, 0)); bool acquired = false; var task = Task.Run(async() => { while (!acquired) { Console.WriteLine("Trying to acquire"); acquired = fileLock.TryAcquireLock(); if (!acquired) { Console.WriteLine("Waiting before trying again"); await Task.Delay(1000, cts.Token); } } }, cts.Token); task.Wait(); if (!acquired) { Console.WriteLine("Didn't acquire the lock in time"); } else { var stillAcquired = fileLock.TryAcquireLock(); Console.WriteLine($"Still acquired: {stillAcquired}"); Console.WriteLine("Work, Work"); Thread.Sleep(10 * 1000); // 10 seconds of work fileLock.ReleaseLock(); Console.WriteLine("Work Complete!"); } Console.WriteLine("Finished"); }
/// <summary> /// Run an action only if this application is not locked /// </summary> /// <typeparam name="T"></typeparam> /// <param name="a"></param> /// <param name="operation"></param> /// <returns></returns> protected T RunActionIfApplicationNotLocked <T>(Func <T> a, string operation) { // Don't let an application be deployed in parallel, could lead to breaks! string lockPath = this.LockPathForApplication(); var fileLock = SimpleFileLock.Create(lockPath, TimeSpan.FromMinutes(3)); if (fileLock.TryAcquireLock() || Debugger.IsAttached) { try { return(a()); } finally { fileLock.ReleaseLock(); } } else { throw new StopDeploymentException($"Could not run operation {operation} because the application is locked in another process {lockPath}."); } }
static void Main(string[] args) { var fileLock = SimpleFileLock.Create(LockName, LockTimeout); Console.WriteLine("Acquiring lock"); var lockAcquired = fileLock.TryAcquireLock(); if (lockAcquired) { Console.WriteLine("Lock Acquired"); Console.WriteLine("Spawning other lock-contending process..."); var p = StartProcess(); Console.WriteLine("Sleeping until lock times out (and not releasing it)..."); Thread.Sleep(TimeSpan.FromSeconds(20)); Console.WriteLine("Waking up..."); Console.WriteLine("Press any key to exit"); Console.ReadKey(); } else { Console.WriteLine("Failed to acquire lock."); } }
public bool ScheduleWork(CancellationToken mainToken, TimeSpan until, int milliSecondsBeforeMoreWork) { var fileLock = SimpleFileLock.Create(LockPath, until); var acquired = fileLock.TryAcquireLock(); if (!acquired) { return(false); } var worker = NextWorker(); var ending = DateTime.Now.Add(until); var workerTokenSource = new CancellationTokenSource(until.Add(TimeSpan.FromSeconds(2))); using (var combinedSource = CancellationTokenSource.CreateLinkedTokenSource(mainToken, workerTokenSource.Token)) { try { var task = Task.Run(async() => { bool cancelled = false; while (DateTime.Now < ending && !cancelled) { Console.WriteLine("Work, Work"); try { worker.Do(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); throw new Exception("While running Worker.Do", ex); } try { await Task.Delay(milliSecondsBeforeMoreWork, mainToken); } catch (TaskCanceledException) { Console.WriteLine("Simulated delay caused by work was cancelled"); cancelled = true; } } ; Console.WriteLine("Work complete!"); } , combinedSource.Token); task.Wait(); } catch (OperationCanceledException) { if (mainToken.IsCancellationRequested) { Console.WriteLine("Main process timed-out"); } else if (workerTokenSource.IsCancellationRequested) { Console.WriteLine("Worker process took longer than allotted"); } } } fileLock.ReleaseLock(); // not strictly required in this case but does remove the lock file return(true); }
// Public methods public static bool IsRunning() { var fileLock = SimpleFileLock.Create(Constants.PIDLOCK_PATH); return(!fileLock.TestLockIsFree()); }
protected override void InnerLoad() { var contentPhysicalPath = _modulesLocalPath; if (string.IsNullOrEmpty(_assembliesPath)) { throw new InvalidOperationException("The AssembliesPath cannot contain a null value or be empty"); } if (string.IsNullOrEmpty(_contentVirtualPath)) { throw new InvalidOperationException("The ContentVirtualPath cannot contain a null value or be empty"); } if (string.IsNullOrEmpty(contentPhysicalPath)) { throw new InvalidOperationException("The ContentPhysicalPath cannot contain a null value or be empty"); } //Use lock file in file system to synhronize multiple platform instances initialization (to avoid collisions on initialization process) var fileLock = SimpleFileLock.Create("vc-lock", TimeSpan.FromMinutes(1)); var needCopyAssemblies = fileLock.TryAcquireLock(); if (!contentPhysicalPath.EndsWith("\\", StringComparison.OrdinalIgnoreCase)) { contentPhysicalPath += "\\"; } var rootUri = new Uri(contentPhysicalPath); if (needCopyAssemblies) { if (!Directory.Exists(_assembliesPath)) { Directory.CreateDirectory(_assembliesPath); } // Clear ~/moules directory from old assemblies // Ignore any errors, because shadow copy may not work try { foreach (var assembly in Directory.GetFiles(_assembliesPath)) { File.Delete(assembly); } } catch (Exception) { } CopyAssemblies(_modulesLocalPath, _assembliesPath); } foreach (var pair in GetModuleManifests()) { var manifest = pair.Value; var manifestPath = pair.Key; var modulePath = Path.GetDirectoryName(manifestPath); if (needCopyAssemblies) { CopyAssemblies(modulePath, _assembliesPath); } var moduleVirtualPath = GetModuleVirtualPath(rootUri, modulePath); ConvertVirtualPath(manifest.Scripts, moduleVirtualPath); ConvertVirtualPath(manifest.Styles, moduleVirtualPath); var moduleInfo = new ManifestModuleInfo(manifest) { FullPhysicalPath = Path.GetDirectoryName(manifestPath) }; // Modules without assembly file don't need initialization if (string.IsNullOrEmpty(manifest.AssemblyFile)) { moduleInfo.State = ModuleState.Initialized; } else { moduleInfo.Ref = GetFileAbsoluteUri(_assembliesPath, manifest.AssemblyFile); } moduleInfo.IsInstalled = true; AddModule(moduleInfo); } //Wait until other (first) platform instance finished initialization (copying assemblies) if (!needCopyAssemblies) { while (!fileLock.TryAcquireLock()) { Thread.Sleep(500); } } //Release file system lock fileLock.ReleaseLock(); }
public static void Main(string[] args) { ExceptionLogging.Initialize("17a42e4a67dd2e42d4aa40d8bf2d23ee", Assembly.GetExecutingAssembly().GetName().Name); var options = QueueManagerOptions.ParseCommandLineArgs(args); if (options == null) { return; } MainClass.Logger.Notice("LfMergeQueueManager starting with args: {0}", string.Join(" ", args)); // initialize the SLDR Sldr.Initialize(); var settings = MainClass.Container.Resolve <LfMergeSettings>(); settings.Initialize(); var fileLock = SimpleFileLock.CreateFromFilePath(settings.LockFile); try { if (!fileLock.TryAcquireLock()) { MainClass.Logger.Error("Can't acquire file lock - is another instance running?"); return; } MainClass.Logger.Notice("Lock acquired"); if (!CheckSetup(settings)) { return; } // Cleanup any hang projects new Janitor(settings, MainClass.Logger).CleanupAndRescheduleJobs(); for (var queue = Queue.FirstQueueWithWork; queue != null; queue = queue.NextQueueWithWork) { var clonedQueue = queue.QueuedProjects.ToList(); foreach (var projectCode in clonedQueue) { var projectPath = Path.Combine(settings.LcmDirectorySettings.ProjectsDirectory, projectCode, $"{projectCode}{LcmFileHelper.ksFwDataXmlFileExtension}"); var modelVersion = FwProject.GetModelVersion(projectPath); queue.DequeueProject(projectCode); int retCode = MainClass.StartLfMerge(projectCode, queue.CurrentActionName, modelVersion, true); // TODO: If LfMerge fails, should we re-queue the project, or not? if (retCode != 0) { // queue.EnqueueProject(projectCode); } } } } catch (Exception e) { MainClass.Logger.Error("Unhandled Exception:\n{0}", e); throw; } finally { if (fileLock != null) { fileLock.ReleaseLock(); } if (Sldr.IsInitialized) { Sldr.Cleanup(); } MainClass.Container.Dispose(); } MainClass.Logger.Notice("LfMergeQueueManager finished"); }