LockedInodePath (Alluxio Parent 2.7.2-SNAPSHOT API)

java.lang.Object
- alluxio.master.file.meta.LockedInodePath

All Implemented Interfaces:

Closeable, AutoCloseable
```
@NotThreadSafe
public class LockedInodePath
extends Object
implements Closeable
```
This class represents a locked path within the inode tree, starting from the root. The mUri and mPathComponents fields are immutable and contain the "target" path represented by the LockedInodePath. mLockList manages the locks held by the LockedInodePath. The mExistingInodes list holds inodes that are locked and known to exist. The inodes might not be individually locked - if one inode is write-locked, the inodes after it are implicitly write-locked and may be added to mExistingInodes. The inodes in mExistingInodes are a prefix of the inodes referenced by mPathComponents. If the full path exists, mExistingInodes will have size equal to mPathComponents.length after traversal. mExistingInodes is always at least as long as the list of inodes directly locked by mLockList. To create new inode paths from an existing path, use one of the lock*() methods. They return new locked inode paths that can be modified and closed without affecting the original path. Modifying the original inode path invalidates any subpaths that it has created. Locked inode paths are not threadsafe and should not be shared across threads.

Field Summary

Fields
Modifier and Type	Field and Description
`protected InodeLockList`	`mLockList` Lock list locking some portion of the path according to mLockPattern.
`protected InodeTree.LockPattern`	`mLockPattern` The locking pattern.
`protected String[]`	`mPathComponents` The components of mUri.
`protected AlluxioURI`	`mUri` Uri for the path represented.

Constructor Summary

Constructors
Constructor and Description
`LockedInodePath(AlluxioURI uri, ReadOnlyInodeStore inodeStore, InodeLockManager inodeLockManager, InodeDirectory root, InodeTree.LockPattern lockPattern, boolean tryLock)` Creates a new locked inode path.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addNextInode(Inode inode)` Adds the next inode to the path.
`void`	`close()`
`void`	`downgradeToRead()` Downgrades all locks in this list to read locks.
`boolean`	`fullPathExists()`
`Inode`	`getAncestorInode()` Returns the closest ancestor of the target inode (last inode in the full path).
`int`	`getExistingInodeCount()`
`Inode`	`getInode()`
`InodeFile`	`getInodeFile()`
`List<Inode>`	`getInodeList()`
`Inode`	`getInodeOrNull()`
`List<InodeView>`	`getInodeViewList()`
`Inode`	`getLastExistingInode()`
`InodeTree.LockPattern`	`getLockPattern()`
`InodeDirectory`	`getParentInodeDirectory()`
`Inode`	`getParentInodeOrNull()`
`AlluxioURI`	`getUri()`
`LockedInodePath`	`lockChild(Inode child, InodeTree.LockPattern lockPattern)` Returns a new locked inode path composed of the current path plus the child inode.
`LockedInodePath`	`lockChild(Inode child, InodeTree.LockPattern lockPattern, String[] childComponentsHint)` Efficient version of `#lockChild(Inode, LockPattern)` for when the child path components are already known.
`LockedInodePath`	`lockDescendant(AlluxioURI descendantUri, InodeTree.LockPattern lockPattern)` Locks a descendant of the current path and returns a new locked inode path.
`LockedInodePath`	`lockFinalEdgeWrite()` Returns a copy of the path with the final edge write locked.
`void`	`removeLastInode()` Removes the last inode from the list.
`int`	`size()`
`String`	`toString()`
`void`	`traverse()` Traverses the inode path according to its lock pattern.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - mUri
```
protected final AlluxioURI mUri
```
    Uri for the path represented.
  - mPathComponents
```
protected final String[] mPathComponents
```
    The components of mUri.
  - mLockList
```
protected final InodeLockList mLockList
```
    Lock list locking some portion of the path according to mLockPattern.
  - mLockPattern
```
protected InodeTree.LockPattern mLockPattern
```
    The locking pattern.
- Constructor Detail
  - LockedInodePath
```
public LockedInodePath(AlluxioURI uri,
                       ReadOnlyInodeStore inodeStore,
                       InodeLockManager inodeLockManager,
                       InodeDirectory root,
                       InodeTree.LockPattern lockPattern,
                       boolean tryLock)
                throws InvalidPathException
```
    Creates a new locked inode path.
    
    Parameters:
    
    uri - the uri for the path
    
    inodeStore - the inode store for looking up inode children
    
    inodeLockManager - the inode lock manager
    
    root - the root inode
    
    lockPattern - the pattern to lock in
    
    tryLock - whether or not use Lock.tryLock() or Lock.lock()
    
    Throws:
    
    InvalidPathException
- Method Detail
  - getUri
```
public AlluxioURI getUri()
```
    Returns:
    
    the full uri of the path
  - getInode
```
public Inode getInode()
               throws FileDoesNotExistException
```
    Returns:
    
    the target inode
    
    Throws:
    
    FileDoesNotExistException - if the target inode does not exist
  - getInodeOrNull
```
@Nullable
public Inode getInodeOrNull()
```
    Returns:
    
    the target inode, or null if it does not exist
  - getInodeFile
```
public InodeFile getInodeFile()
                       throws FileDoesNotExistException
```
    Returns:
    
    the target inode as an MutableInodeFile
    
    Throws:
    
    FileDoesNotExistException - if the target inode does not exist, or it is not a file
  - getParentInodeDirectory
```
public InodeDirectory getParentInodeDirectory()
                                       throws InvalidPathException,
                                              FileDoesNotExistException
```
    Returns:
    
    the parent of the target inode
    
    Throws:
    
    InvalidPathException - if the parent inode is not a directory
    
    FileDoesNotExistException - if the parent of the target does not exist
  - getParentInodeOrNull
```
@Nullable
public Inode getParentInodeOrNull()
```
    Returns:
    
    the parent of the target inode, or null if the parent does not exist
  - getLastExistingInode
```
public Inode getLastExistingInode()
```
    Returns:
    
    the last existing inode on the inode path. This could be out of date if the current thread has added or deleted inodes since the last call to traverse()
  - getInodeList
```
public List<Inode> getInodeList()
```
    Returns:
    
    a copy of the list of existing inodes, from the root
  - getInodeViewList
```
public List<InodeView> getInodeViewList()
```
    Returns:
    
    a copy of the list of existing inodes, from the root
  - getExistingInodeCount
```
public int getExistingInodeCount()
```
    Returns:
    
    the number of existing inodes in this path. This could be out of date if the current thread has added or deleted inodes since the last call to traverse()
  - size
```
public int size()
```
    Returns:
    
    number of components in this locked path
  - fullPathExists
```
public boolean fullPathExists()
```
    Returns:
    
    true if the entire path of inodes exists, false otherwise. This could be out of date if the current thread has added or deleted inodes since the last call to traverse()
  - getLockPattern
```
public InodeTree.LockPattern getLockPattern()
```
    Returns:
    
    the InodeTree.LockPattern of this path
  - removeLastInode
```
public void removeLastInode()
```
    Removes the last inode from the list. This is necessary when the last inode is deleted and we want to continue using the inodepath. This operation is only supported when the path is complete.
  - addNextInode
```
public void addNextInode(Inode inode)
```
    Adds the next inode to the path. This tries to reduce the scope of locking by moving the write lock forward to the new final edge, downgrading the previous write lock to a read lock.
    
    Parameters:
    
    inode - the inode to add
  - downgradeToRead
```
public void downgradeToRead()
```
    Downgrades all locks in this list to read locks.
  - getAncestorInode
```
public Inode getAncestorInode()
                       throws FileDoesNotExistException
```
    Returns the closest ancestor of the target inode (last inode in the full path).
    
    Returns:
    
    the closest ancestor inode
    
    Throws:
    
    FileDoesNotExistException - if an ancestor does not exist
  - lockDescendant
```
public LockedInodePath lockDescendant(AlluxioURI descendantUri,
                                      InodeTree.LockPattern lockPattern)
                               throws InvalidPathException
```
    Locks a descendant of the current path and returns a new locked inode path. The path is traversed according to the lock pattern. Closing the new path will have no effect on the current path. On failure, all locks taken by this method will be released.
    
    Parameters:
    
    descendantUri - the full descendent uri starting from the root
    
    lockPattern - the lock pattern to lock in
    
    Returns:
    
    the new locked path
    
    Throws:
    
    InvalidPathException
  - lockChild
```
public LockedInodePath lockChild(Inode child,
                                 InodeTree.LockPattern lockPattern)
                          throws InvalidPathException
```
    Returns a new locked inode path composed of the current path plus the child inode. The path is traversed according to the lock pattern. The original locked inode path is unaffected. childComponentsHint can be used to save the work of computing path components when the path components for the new path are already known. On failure, all locks taken by this method will be released.
    
    Parameters:
    
    child - the child inode
    
    lockPattern - the lock pattern
    
    Returns:
    
    the new locked path
    
    Throws:
    
    InvalidPathException
  - lockChild
```
public LockedInodePath lockChild(Inode child,
                                 InodeTree.LockPattern lockPattern,
                                 String[] childComponentsHint)
                          throws InvalidPathException
```
    Efficient version of #lockChild(Inode, LockPattern) for when the child path components are already known.
    
    Parameters:
    
    child - the child inode
    
    lockPattern - the lock pattern
    
    childComponentsHint - path components for the new path
    
    Returns:
    
    the new locked path
    
    Throws:
    
    InvalidPathException
  - lockFinalEdgeWrite
```
public LockedInodePath lockFinalEdgeWrite()
                                   throws InvalidPathException
```
    Returns a copy of the path with the final edge write locked. This requires that we haven't already locked the final edge, i.e. the path is incomplete.
    
    Returns:
    
    the new locked path
    
    Throws:
    
    InvalidPathException
  - traverse
```
public void traverse()
              throws InvalidPathException
```
    Traverses the inode path according to its lock pattern. If the inode path is already partially traversed, this method will pick up where the previous traversal left off. On return, all existing inodes in the path are added to mExistingInodes and the inodes are locked according to InodeTree.LockPattern.
    
    Throws:
    
    InvalidPathException
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class LockedInodePath

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

mUri

mPathComponents

mLockList

mLockPattern

Constructor Detail

LockedInodePath

Method Detail

getUri

getInode

getInodeOrNull

getInodeFile

getParentInodeDirectory

getParentInodeOrNull

getLastExistingInode

getInodeList

getInodeViewList

getExistingInodeCount

size

fullPathExists

getLockPattern

removeLastInode

addNextInode

downgradeToRead

getAncestorInode

lockDescendant

lockChild

lockChild

lockFinalEdgeWrite

traverse

close

toString