Beispiel #1
0
        public void TestTryLock_TryLock_Maximum60SecondsLockValueIsAllowed()
        {
            // Arrange
            var client       = new CloudEnvironment();
            var consoleLog   = new ConsoleLogService();
            var lockProvider = new AzureLockStateProvider(consoleLog);
            var factory      = new AzureGlobalMutexFactory((AzureBlobContainer)client.BlobClient.GetContainerReference("globalmutextests7"), lockProvider, consoleLog);

            // Act
            using (var globalMutex = factory.CreateLock("test_lock7", TimeSpan.FromSeconds(59)))
            {
            }
            using (var globalMutex = factory.CreateLock("test_lock7", TimeSpan.FromSeconds(60)))
            {
            }

            try
            {
                using (var globalMutex = factory.CreateLock("test_lock7", TimeSpan.FromSeconds(61)))
                {
                }

                // Assert
                Assert.Fail();
            }
            catch
            {
                // Assert
                Assert.IsTrue(true);
            }
        }
Beispiel #2
0
        public void TestLock_Lock_TryLock_IsNotReleased()
        {
            // Arrange
            var  client = new CloudEnvironment();
            var  result = string.Empty;
            bool isLocked;
            var  consoleLog   = new ConsoleLogService();
            var  lockProvider = new AzureLockStateProvider(consoleLog);
            var  factory      = new AzureGlobalMutexFactory((AzureBlobContainer)client.BlobClient.GetContainerReference("globalmutextests6"), lockProvider, consoleLog);

            // Act
            client.BreakAnyLeases("globalmutextests6", "test_lock");
            var globalMutex = factory.CreateLock("test_lock");

            result += "1";

            using (var globalMutexInner = factory.TryCreateLock("test_lock", out isLocked)) if (isLocked)
                {
                    result += "2";
                }

            globalMutex.Unlock();

            // Assert
            Assert.AreEqual("1", result);
        }
Beispiel #3
0
        public void TestLock_LeaseIsRenewed()
        {
            // Arrange
            var  client = new CloudEnvironment();
            var  result = string.Empty;
            bool isLocked;
            bool isLockedInner;
            var  consoleLog   = new ConsoleLogService();
            var  lockProvider = new AzureLockStateProvider(consoleLog);
            var  factory      = new AzureGlobalMutexFactory((AzureBlobContainer)client.BlobClient.GetContainerReference("globalmutextests4"), lockProvider, consoleLog);

            // Act
            client.BreakAnyLeases("globalmutextests4", "test_lock");
            using (var globalMutex = factory.TryCreateLock("test_lock", TimeSpan.FromSeconds(15), out isLocked))
            {
                if (isLocked)
                {
                    result += "1";
                }

                Thread.Sleep(TimeSpan.FromSeconds(40));
                using (var globalMutexInner = factory.TryCreateLock("test_lock", out isLockedInner)) if (isLockedInner)
                    {
                        result += "2";
                    }
            }

            // Assert
            Assert.AreEqual("1", result);
        }
Beispiel #4
0
        public void TestReacquireLock()
        {
            // Arrange
            var client       = new CloudEnvironment();
            var consoleLog   = new ConsoleLogService();
            var lockProvider = new AzureLockStateProvider(consoleLog);
            var factory      = new AzureGlobalMutexFactory((AzureBlobContainer)client.BlobClient.GetContainerReference("globalmutextests8"), lockProvider, consoleLog);

            // Act
            client.BreakAnyLeases("globalmutextests8", "test_lock");
            var globalMutex = factory.CreateLock("test_lock");
            var lease       = globalMutex.CurrentLeaseId;

            globalMutex.LockAsync("test_lock").Wait();

            // Assert
            Assert.IsTrue(globalMutex.CurrentLeaseId == lease);
        }
Beispiel #5
0
        public void TestLock_Lock_LockIsReleased()
        {
            // Arrange
            var client       = new CloudEnvironment();
            var result       = string.Empty;
            var consoleLog   = new ConsoleLogService();
            var lockProvider = new AzureLockStateProvider(consoleLog);
            var factory      = new AzureGlobalMutexFactory((AzureBlobContainer)client.BlobClient.GetContainerReference("globalmutextests3"), lockProvider, consoleLog);


            // Act
            client.BreakAnyLeases("globalmutextests3", "test_lock");
            using (var globalMutex = factory.CreateLock("test_lock")) result += "1";

            using (var globalMutex = factory.CreateLock("test_lock")) result += "2";

            // Assert
            Assert.AreEqual("12", result);
        }
Beispiel #6
0
        public void TestTryLock_TryLock_Concurrency()
        {
            // Arrange
            var client       = new CloudEnvironment();
            var consoleLog   = new ConsoleLogService();
            var lockProvider = new AzureLockStateProvider(consoleLog);
            var factory      = new AzureGlobalMutexFactory((AzureBlobContainer)client.BlobClient.GetContainerReference("globalmutextests2"), lockProvider, consoleLog);
            var result       = string.Empty;
            var thread1      = new Thread(
                () =>
            {
                bool isLocked;
                using (var globalMutex = factory.TryCreateLock("test_lock", out isLocked))
                {
                    if (isLocked)
                    {
                        result += "1";
                    }
                    Thread.Sleep(2000);
                }
            });
            var thread2 = new Thread(
                () =>
            {
                Thread.Sleep(1000);                         // Ensure it will enter later than the previous method
                bool isLocked;
                using (var globalMutex = factory.TryCreateLock("test_lock", out isLocked)) if (isLocked)
                    {
                        result += "2";
                    }
            });

            // Act
            client.BreakAnyLeases("globalmutextests2", "test_lock");
            thread2.Start();
            thread1.Start();
            thread1.Join();
            thread2.Join();

            // Assert
            Assert.AreEqual("1", result);
        }
Beispiel #7
0
        public void TestLock_Lock_ManyLocks()
        {
            // Arrange
            var client       = new CloudEnvironment();
            var result       = string.Empty;
            var consoleLog   = new ConsoleLogService();
            var lockProvider = new AzureLockStateProvider(consoleLog);
            var factory      = new AzureGlobalMutexFactory((AzureBlobContainer)client.BlobClient.GetContainerReference("globalmutextests11"), lockProvider, consoleLog);

            var thread1 = new Thread(
                () =>
            {
                using (var globalMutex = factory.CreateLock("test_lock"))
                {
                    result += "1";
                    Trace.WriteLine("Thread 1 will sleep  for 90 seconds");
                    Thread.Sleep(TimeSpan.FromSeconds(90));
                    Trace.WriteLine("Thread 1 woke up");
                }
            });

            var thread2 = new Thread(
                () =>
            {
                Thread.Sleep(2000);                         // Ensure it will enter later than the previous method
                using (var globalMutex = factory.CreateLock("test_lock")) result += "2";
            });

            var thread3 = new Thread(
                () =>
            {
                Thread.Sleep(2000);                         // Ensure it will enter later than the previous method
                using (var globalMutex = factory.CreateLock("test_lock")) result += "3";
            });

            var thread4 = new Thread(
                () =>
            {
                Thread.Sleep(2000);                         // Ensure it will enter later than the previous method
                using (var globalMutex = factory.CreateLock("test_lock")) result += "4";
            });

            var thread5 = new Thread(
                () =>
            {
                Thread.Sleep(2000);                         // Ensure it will enter later than the previous method
                using (var globalMutex = factory.CreateLock("test_lock")) result += "5";
            });

            var thread6 = new Thread(
                () =>
            {
                Thread.Sleep(1000);                         // Ensure it will enter later than the previous method
                using (var globalMutex = factory.CreateLock("test_lock")) result += "6";
            });

            // Act
            client.BreakAnyLeases("globalmutextests1", "test_lock");
            thread6.Start();
            thread5.Start();
            thread4.Start();
            thread3.Start();
            thread2.Start();
            thread1.Start();
            thread1.Join();
            thread2.Join();
            thread3.Join();
            thread4.Join();
            thread5.Join();
            thread6.Join();

            // Assert
            Trace.WriteLine(result);
            Assert.IsTrue(result.StartsWith("1"));
            Assert.IsTrue(result.Contains("2"));
            Assert.IsTrue(result.Contains("3"));
            Assert.IsTrue(result.Contains("4"));
            Assert.IsTrue(result.Contains("5"));
            Assert.IsTrue(result.Contains("6"));
        }