import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
/**
 * Invoke the before log policy
 * 
 * @param nodeRef       the node to be locked
 * @param lockType      the lock type
 */
private void invokeBeforeLock(
        NodeRef nodeRef,
        LockType lockType)
{
    if (!nodeService.exists(nodeRef))
    {
        return;
    }
    List<QName> classes = getInvokeClasses(nodeRef);
    for (QName invokeClass : classes)
    {            
        Collection<BeforeLock> policies = beforeLock.getList(invokeClass);
        for (BeforeLock policy : policies) 
        {
            policy.beforeLock(nodeRef, lockType);
        }
    }
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
/**
 * @see org.alfresco.service.cmr.lock.LockService#lock(org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.cmr.lock.LockType, int, Lifetime, boolean)
 */
@Override
@Extend(traitAPI=LockServiceTrait.class,extensionAPI=LockServiceExtension.class)
public void lock(NodeRef nodeRef, LockType lockType, int timeToExpire, Lifetime lifetime, boolean lockChildren)
{
    lock(nodeRef, lockType, timeToExpire, lifetime);

    if (lockChildren)
    {
        Collection<ChildAssociationRef> childAssocRefs = this.nodeService.getChildAssocs(nodeRef);
        for (ChildAssociationRef childAssocRef : childAssocRefs)
        {
            lock(childAssocRef.getChildRef(), lockType, timeToExpire, lifetime, lockChildren);
        }
    }
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
private void persistLockProps(NodeRef nodeRef, LockType lockType, Lifetime lifetime, String userName, Date expiryDate, String additionalInfo)
{  
    addToIgnoreSet(nodeRef);
    try
    {
        // Set the current user as the lock owner
        this.nodeService.setProperty(nodeRef, ContentModel.PROP_LOCK_OWNER, userName);
        this.nodeService.setProperty(nodeRef, ContentModel.PROP_LOCK_TYPE, lockType.toString());
        this.nodeService.setProperty(nodeRef, ContentModel.PROP_LOCK_LIFETIME, lifetime.toString());
        this.nodeService.setProperty(nodeRef, ContentModel.PROP_EXPIRY_DATE, expiryDate);
        this.nodeService.setProperty(nodeRef, ContentModel.PROP_LOCK_ADDITIONAL_INFO, additionalInfo);
    } 
    finally
    {
        removeFromIgnoreSet(nodeRef);
    }
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
/**
 * @see LockService#getLockType(NodeRef)
 */
@Extend(traitAPI=LockServiceTrait.class,extensionAPI=LockServiceExtension.class)
public LockType getLockType(NodeRef nodeRef)
{
    LockType result = null;

    // Don't disable the lockable aspect interceptor - allow it to fetch the lock type
    // from the correct place (persistent storage or lockStore).
    if (this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_LOCKABLE) == true)
    {
        String lockTypeString = (String) this.nodeService.getProperty(nodeRef, ContentModel.PROP_LOCK_TYPE);
        if (lockTypeString != null)
        {
            result = LockType.valueOf(lockTypeString);
        }
    }

    return result;
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
/**
 * Ensures that the parent is not locked.
 * 
 * @see #checkForLock(NodeRef)
 */
public void onCreateChildAssociation(ChildAssociationRef childAssocRef, boolean isNewNode)
{
    LockType lockType = getLockType(childAssocRef.getParentRef());
    if(lockType != null)
    {
    
        switch (lockType)
        {
            case WRITE_LOCK:
            case READ_ONLY_LOCK:
                checkForLock(childAssocRef.getParentRef());
                break;
            case NODE_LOCK:
            // don't check for lock
        }
    }
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Extend(traitAPI=LockServiceTrait.class,extensionAPI=LockServiceExtension.class)
public boolean isLockedAndReadOnly(NodeRef nodeRef)
{
    LockStatus lockStatus = getLockStatus(nodeRef);
    switch (lockStatus)
    {
        case NO_LOCK:
        case LOCK_EXPIRED:
            return false;
        case LOCK_OWNER:
            return getLockType(nodeRef) != LockType.WRITE_LOCK;
        default:
            return true;
    }
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
public void testHasLockableAspect() throws Exception
{
    assertFalse("Node should not be reported as lockable",
                nodeService.hasAspect(originalContentNodeRef,
                                      ContentModel.ASPECT_LOCKABLE));

    lockService.lock(originalContentNodeRef,
                     LockType.WRITE_LOCK,
                     10,
                     Lifetime.EPHEMERAL,
                     null);

    assertTrue("Node should be reported as lockable",
               nodeService.hasAspect(originalContentNodeRef,
                                     ContentModel.ASPECT_LOCKABLE));
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
/**
 * Test version service lock checking
 */
public void testVersionServiceLockBehaviour02()
{
    // Add the version aspect to the node
    this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_VERSIONABLE, null);
    
    // Lock the node as the bad user with a write lock
    this.lockService.lock(this.nodeRef, LockType.WRITE_LOCK);
    try
    {
        TestWithUserUtils.authenticateUser(BAD_USER_NAME, PWD, rootNodeRef, this.authenticationService); 
        
        this.versionService.createVersion(this.nodeRef, new HashMap<String, Serializable>());
        fail("Should have failed since this node has been locked by another user with a write lock.");
    }
    catch (AccessDeniedException exception)
    {
        // Exception occurs when the properties are updated for a node
    }
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
@Category(RedundantTests.class)
public void testEphemeralLockIndexing()
{
    TestWithUserUtils.authenticateUser(GOOD_USER_NAME, PWD, rootNodeRef, authenticationService);
    
    IndexerAndSearcher indexerAndSearcher = (IndexerAndSearcher)
                applicationContext.getBean("indexerAndSearcherFactory");
    SearcherComponent searcher = new SearcherComponent();
    searcher.setIndexerAndSearcherFactory(indexerAndSearcher);

    // Create a lock (owned by the current user)
    lockService.lock(noAspectNode, LockType.WRITE_LOCK, 86400, Lifetime.EPHEMERAL);
    
    // Query for the user's locks
    final String query = String.format("[email protected]\\:lockOwner:\"%s\" [email protected]\\:lockType:\"WRITE_LOCK\"", GOOD_USER_NAME);
    ResultSet rs = searcher.query(storeRef, "lucene", query);
    assertTrue(rs.getNodeRefs().contains(noAspectNode));
    
    // Unlock the node
    lockService.unlock(noAspectNode);
    
    // Perform a new search, the index should reflect that it is not locked.
    rs = searcher.query(storeRef, "lucene", query);
    assertFalse(rs.getNodeRefs().contains(noAspectNode));
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
public void testSetAndGet()
{
    NodeRef ephemeralNodeRef = new NodeRef("workspace://SpacesStore/12345");
    LockState ephemeralLock = LockState.createLock(
                ephemeralNodeRef, LockType.NODE_LOCK, "owner", null, Lifetime.EPHEMERAL, null);
    
    NodeRef persistentNodeRef = new NodeRef("workspace://SpacesStore/5838743");
    LockState persistentLock = LockState.createLock(
                persistentNodeRef, LockType.NODE_LOCK, "owner", null, Lifetime.PERSISTENT, null);
    
    lockStore.set(ephemeralNodeRef, ephemeralLock);
    lockStore.set(persistentNodeRef, persistentLock);
    
    LockState newLockState = lockStore.get(ephemeralNodeRef);
    assertEquals(ephemeralLock, newLockState);
    
    newLockState = lockStore.get(persistentNodeRef);
    assertEquals(persistentLock, newLockState);
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
public void testContains()
{
    NodeRef nodeRef1 = new NodeRef("workspace://SpacesStore/12345");
    LockState lock1 = LockState.createLock(nodeRef1, LockType.NODE_LOCK, "owner", null, Lifetime.EPHEMERAL, null);
    
    NodeRef nodeRef2 = new NodeRef("workspace://SpacesStore/5838743");
    LockState lock2 = LockState.createLock(nodeRef2, LockType.NODE_LOCK, "owner", null, Lifetime.PERSISTENT, null);
    
    NodeRef nodeRef3 = new NodeRef("workspace://SpacesStore/65752323");
    
    lockStore.set(nodeRef1, lock1);
    lockStore.set(nodeRef2, lock2);
    
    assertNotNull(lockStore.get(nodeRef1));
    assertNotNull(lockStore.get(nodeRef2));
    assertNull(lockStore.get(nodeRef3));
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
public void testClear()
{
    NodeRef nodeRef1 = new NodeRef("workspace://SpacesStore/12345");
    LockState lock1 = LockState.createLock(nodeRef1, LockType.NODE_LOCK, "owner", null, Lifetime.EPHEMERAL, null);
    
    NodeRef nodeRef2 = new NodeRef("workspace://SpacesStore/5838743");
    LockState lock2 = LockState.createLock(nodeRef2, LockType.NODE_LOCK, "owner", null, Lifetime.PERSISTENT, null);
    
    lockStore.set(nodeRef1, lock1);
    lockStore.set(nodeRef2, lock2);
    
    assertNotNull(lockStore.get(nodeRef1));
    assertNotNull(lockStore.get(nodeRef2));
    
    lockStore.clear();
    
    assertNull(lockStore.get(nodeRef1));
    assertNull(lockStore.get(nodeRef2));
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
public void testHasAspectEphemeralLock()
{
    QName nodeName = QName.createQName("http://www.alfresco.org/test/" + getClass().getSimpleName(), "testNode");
    NodeRef nodeRef = nodeService.createNode(
                rootNode,
                ContentModel.ASSOC_CHILDREN,
                nodeName,
                ContentModel.TYPE_BASE).getChildRef();
    
    assertFalse("Node should not be reported as lockable",
                nodeService.hasAspect(nodeRef, ContentModel.ASPECT_LOCKABLE));
    
    lockStore.set(nodeRef, LockState.createLock(nodeRef, LockType.WRITE_LOCK, lockOwner, null, Lifetime.EPHEMERAL, null));
    
    assertTrue("Node should be reported as lockable",
                nodeService.hasAspect(nodeRef, ContentModel.ASPECT_LOCKABLE));
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
public void testHasAspectPersistentLock()
{
    QName nodeName = QName.createQName("http://www.alfresco.org/test/" + getClass().getSimpleName(), "testNode");
    NodeRef nodeRef = nodeService.createNode(
                rootNode,
                ContentModel.ASSOC_CHILDREN,
                nodeName,
                ContentModel.TYPE_BASE).getChildRef();
    
    assertFalse("Node should not be reported as lockable",
                nodeService.hasAspect(nodeRef, ContentModel.ASPECT_LOCKABLE));
    
    lockStore.set(nodeRef,
                LockState.createLock(nodeRef, LockType.WRITE_LOCK, lockOwner, null, Lifetime.PERSISTENT, null));

    // Persistent lock should not result in the aspects being augmented
    assertFalse("Node should not be reported as lockable",
                nodeService.hasAspect(nodeRef, ContentModel.ASPECT_LOCKABLE));
    
    nodeService.addAspect(nodeRef, ContentModel.ASPECT_LOCKABLE, new HashMap<QName, Serializable>(0));
    
    // The existence of the real aspect should be reported.
    assertTrue("Node should be reported as lockable",
                nodeService.hasAspect(nodeRef, ContentModel.ASPECT_LOCKABLE));
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
public void mnt13183LockInfo()
{
    // CIFS lock node to 1 hour
    lockService.lock(nodeRef1, LockType.WRITE_LOCK, 3600, Lifetime.EPHEMERAL, "lock_info_that_is_not_from_webdav");

    // WebDAV get lock info
    LockInfo lockInfoNodeRef1 = davLockService.getLockInfo(nodeRef1);
    assertNull("exclusiveLockToken is null", lockInfoNodeRef1.getExclusiveLockToken());
    
    String user = AuthenticationUtil.getFullyAuthenticatedUser();
    
    // WebDav lock, check marker
    davLockService.lock(nodeRef2, user, 3600);
    
    LockState lockState2 = lockService.getLockState(nodeRef2);
    assertNotNull("lockState is not null", lockState2);
    
    String additionalInfo2 = lockState2.getAdditionalInfo();
    assertNotNull("additionalInfo is not null", additionalInfo2);
    assertTrue("Check WEBDAV_LOCK marker", additionalInfo2.startsWith(LockInfoImpl.ADDINFO_WEBDAV_MARKER));   
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
public void testEphemeralLockIndexing()
{
    TestWithUserUtils.authenticateUser(GOOD_USER_NAME, PWD, rootNodeRef, authenticationService);
    
    IndexerAndSearcher indexerAndSearcher = (IndexerAndSearcher)
                applicationContext.getBean("indexerAndSearcherFactory");
    SearcherComponent searcher = new SearcherComponent();
    searcher.setIndexerAndSearcherFactory(indexerAndSearcher);

    // Create a lock (owned by the current user)
    lockService.lock(noAspectNode, LockType.WRITE_LOCK, 86400, Lifetime.EPHEMERAL);
    
    // Query for the user's locks
    final String query = String.format("[email protected]\\:lockOwner:\"%s\" [email protected]\\:lockType:\"WRITE_LOCK\"", GOOD_USER_NAME);
    ResultSet rs = searcher.query(storeRef, "lucene", query);
    assertTrue(rs.getNodeRefs().contains(noAspectNode));
    
    // Unlock the node
    lockService.unlock(noAspectNode);
    
    // Perform a new search, the index should reflect that it is not locked.
    rs = searcher.query(storeRef, "lucene", query);
    assertFalse(rs.getNodeRefs().contains(noAspectNode));
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Test
public void testGetPropertyEphemeralLock()
{
  QName nodeName = QName.createQName("http://www.alfresco.org/test/" + getClass().getSimpleName(), "testNode");
  NodeRef nodeRef = nodeService.createNode(
              rootNode,
              ContentModel.ASSOC_CHILDREN,
              nodeName,
              ContentModel.TYPE_BASE).getChildRef();
  
  assertEquals(null, nodeService.getProperty(nodeRef, ContentModel.PROP_LOCK_OWNER));
  assertEquals(null, nodeService.getProperty(nodeRef, ContentModel.PROP_LOCK_TYPE));
  assertEquals(null, nodeService.getProperty(nodeRef, ContentModel.PROP_EXPIRY_DATE));
  assertEquals(null, nodeService.getProperty(nodeRef, ContentModel.PROP_LOCK_LIFETIME));
  Date now = new Date();
  // Set a lock on the node
  lockStore.set(nodeRef,
              LockState.createLock(nodeRef, LockType.WRITE_LOCK, lockOwner, now, Lifetime.EPHEMERAL, null));
  
  // cm:lockable properties should be spoofed
  assertEquals(lockOwner, nodeService.getProperty(nodeRef, ContentModel.PROP_LOCK_OWNER));
  assertEquals(LockType.WRITE_LOCK.toString(), nodeService.getProperty(nodeRef, ContentModel.PROP_LOCK_TYPE));
  assertEquals(now, nodeService.getProperty(nodeRef, ContentModel.PROP_EXPIRY_DATE));
  assertEquals(Lifetime.EPHEMERAL.toString(), nodeService.getProperty(nodeRef, ContentModel.PROP_LOCK_LIFETIME));
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Override
public void addLock(NodeRef nodeRef) 
{
	if(lockEnabled)
	{
		if(logger.isDebugEnabled())
		{
			logger.debug("lock nodeRef:" + nodeRef);
		}
	    getLockService().lock(nodeRef, LockType.WRITE_LOCK, getTimeToExpire(), Lifetime.EPHEMERAL, LOCK_KEEPER_KEY);
	    lockKeeperTransactionalCache.put(nodeRef, new KeeperInfo(AuthenticationUtil.getFullyAuthenticatedUser()));
	}
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
@Override
public void lock(NodeRef nodeRef, LockType lockType, int timeToExpire) throws UnableToAquireLockException
{
    getTrait().lock(smartStore.materializeIfPossible(nodeRef),
                    lockType,
                    timeToExpire);
}
 

import org.alfresco.service.cmr.lock.LockType; //导入依赖的package包/类
/**
 * Constructor.
 * 
 * @param nodeRef NodeRef
 * @param lockType LockType
 * @param owner String
 * @param expires Date
 * @param lifetime Lifetime
 * @param additionalInfo String
 */
private LockState(NodeRef nodeRef, LockType lockType, String owner, Date expires,
            Lifetime lifetime, String additionalInfo)
{
    this.nodeRef = nodeRef;
    this.lockType = lockType;
    this.owner = owner;
    this.expires = (expires == null ? null : new Date(expires.getTime()));
    this.lifetime = lifetime;
    this.additionalInfo = additionalInfo;
}