public static LockServiceProtos.LockedResource convertToProtoLockedResource( LockedResource lockedResource) throws IOException { LockServiceProtos.LockedResource.Builder builder = LockServiceProtos.LockedResource.newBuilder(); builder .setResourceType(convertToProtoResourceType(lockedResource.getResourceType())) .setResourceName(lockedResource.getResourceName()) .setLockType(convertToProtoLockType(lockedResource.getLockType())); Procedure<?> exclusiveLockOwnerProcedure = lockedResource.getExclusiveLockOwnerProcedure(); if (exclusiveLockOwnerProcedure != null) { ProcedureProtos.Procedure exclusiveLockOwnerProcedureProto = convertToProtoProcedure(exclusiveLockOwnerProcedure); builder.setExclusiveLockOwnerProcedure(exclusiveLockOwnerProcedureProto); } builder.setSharedLockCount(lockedResource.getSharedLockCount()); for (Procedure<?> waitingProcedure : lockedResource.getWaitingProcedures()) { ProcedureProtos.Procedure waitingProcedureProto = convertToProtoProcedure(waitingProcedure); builder.addWaitingProcedures(waitingProcedureProto); } return builder.build(); }
private LockedResource createLockedResource(LockedResourceType resourceType, String resourceName, LockAndQueue queue) { LockType lockType; Procedure<?> exclusiveLockOwnerProcedure; int sharedLockCount; if (queue.hasExclusiveLock()) { lockType = LockType.EXCLUSIVE; exclusiveLockOwnerProcedure = queue.getExclusiveLockOwnerProcedure(); sharedLockCount = 0; } else { lockType = LockType.SHARED; exclusiveLockOwnerProcedure = null; sharedLockCount = queue.getSharedLockCount(); } List<Procedure<?>> waitingProcedures = new ArrayList<>(); queue.filterWaitingQueue(p -> p instanceof LockProcedure) .forEachOrdered(waitingProcedures::add); return new LockedResource(resourceType, resourceName, lockType, exclusiveLockOwnerProcedure, sharedLockCount, waitingProcedures); }
/** * Get lock info for a resource of specified type and name and log details */ private void logLockedResource(LockedResourceType resourceType, String resourceName) { if (!LOG.isDebugEnabled()) { return; } LockedResource lockedResource = getLockResource(resourceType, resourceName); if (lockedResource != null) { String msg = resourceType.toString() + " '" + resourceName + "', shared lock count=" + lockedResource.getSharedLockCount(); Procedure<?> proc = lockedResource.getExclusiveLockOwnerProcedure(); if (proc != null) { msg += ", exclusively locked by procId=" + proc.getProcId(); } LOG.debug(msg); } }
private static void assertExclusiveLock(LockedResource resource, Procedure<?> procedure) { assertEquals(LockType.EXCLUSIVE, resource.getLockType()); assertEquals(procedure, resource.getExclusiveLockOwnerProcedure()); assertEquals(0, resource.getSharedLockCount()); }
@Test public void testListLocksTable() throws Exception { LockProcedure procedure = createExclusiveLockProcedure(2); queue.waitTableExclusiveLock(procedure, TableName.valueOf("ns2", "table2")); List<LockedResource> locks = queue.getLocks(); assertEquals(2, locks.size()); LockedResource namespaceResource = locks.get(0); assertLockResource(namespaceResource, LockedResourceType.NAMESPACE, "ns2"); assertSharedLock(namespaceResource, 1); assertTrue(namespaceResource.getWaitingProcedures().isEmpty()); LockedResource tableResource = locks.get(1); assertLockResource(tableResource, LockedResourceType.TABLE, "ns2:table2"); assertExclusiveLock(tableResource, procedure); assertTrue(tableResource.getWaitingProcedures().isEmpty()); }
private static void assertLockResource(LockedResource resource, LockedResourceType resourceType, String resourceName) { assertEquals(resourceType, resource.getResourceType()); assertEquals(resourceName, resource.getResourceName()); }
private static void assertSharedLock(LockedResource resource, int lockCount) { assertEquals(LockType.SHARED, resource.getLockType()); assertEquals(lockCount, resource.getSharedLockCount()); }
private static void assertExclusiveLock(LockedResource resource, Procedure<?> procedure) { assertEquals(LockType.EXCLUSIVE, resource.getLockType()); assertEquals(procedure, resource.getExclusiveLockOwnerProcedure()); assertEquals(0, resource.getSharedLockCount()); }
@Test public void testListLocksNamespace() throws Exception { LockProcedure procedure = createExclusiveLockProcedure(1); queue.waitNamespaceExclusiveLock(procedure, "ns1"); List<LockedResource> locks = queue.getLocks(); assertEquals(2, locks.size()); LockedResource namespaceResource = locks.get(0); assertLockResource(namespaceResource, LockedResourceType.NAMESPACE, "ns1"); assertExclusiveLock(namespaceResource, procedure); assertTrue(namespaceResource.getWaitingProcedures().isEmpty()); LockedResource tableResource = locks.get(1); assertLockResource(tableResource, LockedResourceType.TABLE, TableProcedureInterface.DUMMY_NAMESPACE_TABLE_NAME.getNameAsString()); assertSharedLock(tableResource, 1); assertTrue(tableResource.getWaitingProcedures().isEmpty()); }
private static void assertLockResource(LockedResource resource, LockedResourceType resourceType, String resourceName) { assertEquals(resourceType, resource.getResourceType()); assertEquals(resourceName, resource.getResourceName()); }
private static void assertSharedLock(LockedResource resource, int lockCount) { assertEquals(LockType.SHARED, resource.getLockType()); assertEquals(lockCount, resource.getSharedLockCount()); }
for (LockedResource lockedResource : lockedResources) { out.write("\n <h2>"); out.print( lockedResource.getResourceType() ); out.write(':'); out.write(' '); out.print( lockedResource.getResourceName() ); out.write("</h2>\n "); switch (lockedResource.getLockType()) { case EXCLUSIVE: out.print( escapeXml(ProcedureDescriber.describe(lockedResource.getExclusiveLockOwnerProcedure())) ); out.write("</p>\n "); out.print( lockedResource.getSharedLockCount() ); out.write("</p>\n "); List<Procedure<?>> waitingProcedures = lockedResource.getWaitingProcedures();
@Test public void testListLocksRegion() throws Exception { LockProcedure procedure = createExclusiveLockProcedure(3); RegionInfo regionInfo = RegionInfoBuilder.newBuilder(TableName.valueOf("ns3", "table3")).build(); queue.waitRegion(procedure, regionInfo); List<LockedResource> resources = queue.getLocks(); assertEquals(3, resources.size()); LockedResource namespaceResource = resources.get(0); assertLockResource(namespaceResource, LockedResourceType.NAMESPACE, "ns3"); assertSharedLock(namespaceResource, 1); assertTrue(namespaceResource.getWaitingProcedures().isEmpty()); LockedResource tableResource = resources.get(1); assertLockResource(tableResource, LockedResourceType.TABLE, "ns3:table3"); assertSharedLock(tableResource, 1); assertTrue(tableResource.getWaitingProcedures().isEmpty()); LockedResource regionResource = resources.get(2); assertLockResource(regionResource, LockedResourceType.REGION, regionInfo.getEncodedName()); assertExclusiveLock(regionResource, procedure); assertTrue(regionResource.getWaitingProcedures().isEmpty()); }
public static LockServiceProtos.LockedResource convertToProtoLockedResource( LockedResource lockedResource) throws IOException { LockServiceProtos.LockedResource.Builder builder = LockServiceProtos.LockedResource.newBuilder(); builder .setResourceType(convertToProtoResourceType(lockedResource.getResourceType())) .setResourceName(lockedResource.getResourceName()) .setLockType(convertToProtoLockType(lockedResource.getLockType())); Procedure<?> exclusiveLockOwnerProcedure = lockedResource.getExclusiveLockOwnerProcedure(); if (exclusiveLockOwnerProcedure != null) { ProcedureProtos.Procedure exclusiveLockOwnerProcedureProto = convertToProtoProcedure(exclusiveLockOwnerProcedure); builder.setExclusiveLockOwnerProcedure(exclusiveLockOwnerProcedureProto); } builder.setSharedLockCount(lockedResource.getSharedLockCount()); for (Procedure<?> waitingProcedure : lockedResource.getWaitingProcedures()) { ProcedureProtos.Procedure waitingProcedureProto = convertToProtoProcedure(waitingProcedure); builder.addWaitingProcedures(waitingProcedureProto); } return builder.build(); }
@Test public void testListLocksServer() throws Exception { LockProcedure procedure = createExclusiveLockProcedure(0); queue.waitServerExclusiveLock(procedure, ServerName.valueOf("server1,1234,0")); List<LockedResource> resources = queue.getLocks(); assertEquals(1, resources.size()); LockedResource serverResource = resources.get(0); assertLockResource(serverResource, LockedResourceType.SERVER, "server1,1234,0"); assertExclusiveLock(serverResource, procedure); assertTrue(serverResource.getWaitingProcedures().isEmpty()); }
public static LockServiceProtos.LockedResource convertToProtoLockedResource( LockedResource lockedResource) throws IOException { LockServiceProtos.LockedResource.Builder builder = LockServiceProtos.LockedResource.newBuilder(); builder .setResourceType(convertToProtoResourceType(lockedResource.getResourceType())) .setResourceName(lockedResource.getResourceName()) .setLockType(convertToProtoLockType(lockedResource.getLockType())); Procedure<?> exclusiveLockOwnerProcedure = lockedResource.getExclusiveLockOwnerProcedure(); if (exclusiveLockOwnerProcedure != null) { ProcedureProtos.Procedure exclusiveLockOwnerProcedureProto = convertToProtoProcedure(exclusiveLockOwnerProcedure); builder.setExclusiveLockOwnerProcedure(exclusiveLockOwnerProcedureProto); } builder.setSharedLockCount(lockedResource.getSharedLockCount()); for (Procedure<?> waitingProcedure : lockedResource.getWaitingProcedures()) { ProcedureProtos.Procedure waitingProcedureProto = convertToProtoProcedure(waitingProcedure); builder.addWaitingProcedures(waitingProcedureProto); } return builder.build(); } }
@Test public void testListLocksWaiting() throws Exception { LockProcedure procedure1 = createExclusiveLockProcedure(1); queue.waitTableExclusiveLock(procedure1, TableName.valueOf("ns4", "table4")); LockProcedure procedure2 = createSharedLockProcedure(2); queue.waitTableSharedLock(procedure2, TableName.valueOf("ns4", "table4")); LockProcedure procedure3 = createExclusiveLockProcedure(3); queue.waitTableExclusiveLock(procedure3, TableName.valueOf("ns4", "table4")); List<LockedResource> resources = queue.getLocks(); assertEquals(2, resources.size()); LockedResource namespaceResource = resources.get(0); assertLockResource(namespaceResource, LockedResourceType.NAMESPACE, "ns4"); assertSharedLock(namespaceResource, 1); assertTrue(namespaceResource.getWaitingProcedures().isEmpty()); LockedResource tableLock = resources.get(1); assertLockResource(tableLock, LockedResourceType.TABLE, "ns4:table4"); assertExclusiveLock(tableLock, procedure1); List<Procedure<?>> waitingProcedures = tableLock.getWaitingProcedures(); assertEquals(2, waitingProcedures.size()); LockProcedure waitingProcedure2 = (LockProcedure) waitingProcedures.get(0); assertEquals(LockType.SHARED, waitingProcedure2.getType()); assertEquals(procedure2, waitingProcedure2); LockProcedure waitingProcedure3 = (LockProcedure) waitingProcedures.get(1); assertEquals(LockType.EXCLUSIVE, waitingProcedure3.getType()); assertEquals(procedure3, waitingProcedure3); }
@Test public void testListLocksPeer() throws Exception { String peerId = "1"; LockProcedure procedure = createExclusiveLockProcedure(4); queue.waitPeerExclusiveLock(procedure, peerId); List<LockedResource> locks = queue.getLocks(); assertEquals(1, locks.size()); LockedResource resource = locks.get(0); assertLockResource(resource, LockedResourceType.PEER, peerId); assertExclusiveLock(resource, procedure); assertTrue(resource.getWaitingProcedures().isEmpty()); // Try to acquire the exclusive lock again with same procedure assertFalse(queue.waitPeerExclusiveLock(procedure, peerId)); // Try to acquire the exclusive lock again with new procedure LockProcedure procedure2 = createExclusiveLockProcedure(5); assertTrue(queue.waitPeerExclusiveLock(procedure2, peerId)); // Same peerId, still only has 1 LockedResource locks = queue.getLocks(); assertEquals(1, locks.size()); resource = locks.get(0); assertLockResource(resource, LockedResourceType.PEER, peerId); // LockedResource owner still is the origin procedure assertExclusiveLock(resource, procedure); // The new procedure should in the waiting list assertEquals(1, resource.getWaitingProcedures().size()); }
@Test public void testListLocksTable() throws Exception { LockProcedure procedure = createExclusiveLockProcedure(2); queue.waitTableExclusiveLock(procedure, TableName.valueOf("ns2", "table2")); List<LockedResource> locks = queue.getLocks(); assertEquals(2, locks.size()); LockedResource namespaceResource = locks.get(0); assertLockResource(namespaceResource, LockedResourceType.NAMESPACE, "ns2"); assertSharedLock(namespaceResource, 1); assertTrue(namespaceResource.getWaitingProcedures().isEmpty()); LockedResource tableResource = locks.get(1); assertLockResource(tableResource, LockedResourceType.TABLE, "ns2:table2"); assertExclusiveLock(tableResource, procedure); assertTrue(tableResource.getWaitingProcedures().isEmpty()); }
@Test public void testListLocksNamespace() throws Exception { LockProcedure procedure = createExclusiveLockProcedure(1); queue.waitNamespaceExclusiveLock(procedure, "ns1"); List<LockedResource> locks = queue.getLocks(); assertEquals(2, locks.size()); LockedResource namespaceResource = locks.get(0); assertLockResource(namespaceResource, LockedResourceType.NAMESPACE, "ns1"); assertExclusiveLock(namespaceResource, procedure); assertTrue(namespaceResource.getWaitingProcedures().isEmpty()); LockedResource tableResource = locks.get(1); assertLockResource(tableResource, LockedResourceType.TABLE, TableName.NAMESPACE_TABLE_NAME.getNameAsString()); assertSharedLock(tableResource, 1); assertTrue(tableResource.getWaitingProcedures().isEmpty()); }