org.filesys.server.filesys.cache.cluster.ClusterFileState Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jfileserver Show documentation
Show all versions of jfileserver Show documentation
Java file server with SMB, FTP/FTPS and NFS support, virtual filesystems, database filesystems
/*
* Copyright (C) 2006-2010 Alfresco Software Limited.
* Copyright (C) 2018 GK Spencer
*
* This file is part of Alfresco
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see getAttributeMap(boolean createMap) {
HashMap attrMap = null;
if (getStateCache() != null) {
PerNodeState perNode = getStateCache().getPerNodeState(this, createMap);
if (perNode != null)
attrMap = perNode.getAttributeMap(createMap);
}
return attrMap;
}
/**
* Return the pseudo file list, optionally create a new list
*
* @param createList boolean
* @return PseudoFileList
*/
protected PseudoFileList getPseudoFileList(boolean createList) {
PseudoFileList pseudoList = null;
if (getStateCache() != null) {
PerNodeState perNode = getStateCache().getPerNodeState(this, createList);
if (perNode != null)
pseudoList = perNode.getPseudoFileList(createList);
}
return pseudoList;
}
/**
* Return the filesystem object
*
* @return Object
*/
public Object getFilesystemObject() {
Object fileSysObj = null;
if (getStateCache() != null) {
PerNodeState perNode = getStateCache().getPerNodeState(this, false);
if (perNode != null)
fileSysObj = perNode.getFilesystemObject();
}
return fileSysObj;
}
/**
* Set the filesystem object
*
* @param filesysObj Object
*/
public void setFilesystemObject(Object filesysObj) {
if (getStateCache() != null) {
PerNodeState perNode = getStateCache().getPerNodeState(this, true);
if (perNode != null)
perNode.setFilesystemObject(filesysObj);
}
}
/**
* Check if the file has an active local oplock
*
* @return boolean
*/
public boolean hasLocalOpLock() {
boolean oplockSts = false;
if (getStateCache() != null) {
PerNodeState perNode = getStateCache().getPerNodeState(this, false);
if (perNode != null && perNode.hasOpLock())
oplockSts = true;
}
return oplockSts;
}
/**
* Return the local oplock details
*
* @return LocalOpLockDetails
*/
public LocalOpLockDetails getLocalOpLock() {
LocalOpLockDetails localOpLock = null;
if (getStateCache() != null) {
PerNodeState perNode = getStateCache().getPerNodeState(this, false);
if (perNode != null && perNode.hasOpLock())
localOpLock = perNode.getOpLock();
}
return localOpLock;
}
/**
* Set the oplock for this file
*
* @param oplock LocalOpLockDetails
* @throws ExistingOpLockException If there is an active oplock on this file
*/
public synchronized void setLocalOpLock(LocalOpLockDetails oplock)
throws ExistingOpLockException {
if (getStateCache() != null) {
PerNodeState perNode = getStateCache().getPerNodeState(this, true);
if (perNode != null)
perNode.setOpLock(oplock);
}
}
/**
* Clear the oplock
*/
public synchronized void clearLocalOpLock() {
if (getStateCache() != null) {
PerNodeState perNode = getStateCache().getPerNodeState(this, false);
if (perNode != null)
perNode.clearOpLock();
}
}
/**
* Check if the file is readable for the specified section of the file and process id
*
* @param offset long
* @param len long
* @param pid int
* @return boolean
*/
public boolean canReadFile(long offset, long len, int pid) {
if (getStateCache() != null)
return getStateCache().canReadFile(this, offset, len, pid);
throw new RuntimeException("State cache not set for cluster state, path=" + getPath() + " (canRead)");
}
/**
* Check if the file is writeable for the specified section of the file and process id
*
* @param offset long
* @param len long
* @param pid int
* @return boolean
*/
public boolean canWriteFile(long offset, long len, int pid) {
if (getStateCache() != null)
return getStateCache().canWriteFile(this, offset, len, pid);
throw new RuntimeException("State cache not set for cluster state, path=" + getPath() + " (canWrite)");
}
/**
* Return the pending updates mask
*
* @return int
*/
public final int getPendingUpdates() {
return m_stateUpdates;
}
/**
* Clear the pending updates flags and return the current update mask value
*
* @return int
*/
public final int clearPendingUpdates() {
int updMask = m_stateUpdates;
m_stateUpdates = 0;
return updMask;
}
/**
* Set the update mask
*
* @param updMask int
*/
public final void setUpdateMask(int updMask) {
m_stateUpdates = updMask;
}
/**
* Set the file status value, internal method
*
* @param fSts FileStatus
* @param reason ChangeReason
*/
public final void setFileStatusInternal(FileStatus fSts, ChangeReason reason) {
super.setFileStatus(fSts, reason);
m_fileStsReason = reason;
}
/**
* Return the file status change reason code
*
* @return ChangeReason
*/
public final ChangeReason getStatusChangeReason() {
return m_fileStsReason;
}
/**
* Set the file status change reason code
*
* @param reason ChangeReason
*/
public final void setStatusChangeReason(ChangeReason reason) {
m_fileStsReason = reason;
}
/**
* Check if there is a data update in progress for this file
*
* @return boolean
*/
public boolean hasDataUpdateInProgress() {
// Check if there is a data update in progress for this file
if (m_dataUpdateNode != null && m_dataUpdateNode instanceof ClusterNode) {
// If the update is by the local node we ignore it, only return true if
// the data update is on a remote node
if (getStateCache() != null) {
// Check if the data update is on the local node
ClusterNode updateNode = (ClusterNode) m_dataUpdateNode;
if (getStateCache().getCluster().getLocalNode().equals(updateNode))
return false;
}
// Remote data update in progress for this file, or cannot determine if the local
// node is updating the data
return true;
}
// No data update in progress
return false;
}
/**
* Return the data update node details, or null if no data update is in progress
*
* @return Object
*/
public Object getDataUpdateNode() {
return m_dataUpdateNode;
}
/**
* Set the data update node details
*
* @param updateNode Object
*/
public void setDataUpdateNode(Object updateNode) {
m_dataUpdateNode = updateNode;
}
/**
* Return the update mask as a string
*
* @param updMask int
* @return String
*/
public static final String getUpdateMaskAsString(int updMask) {
if (updMask == 0)
return "[Empty]";
StringBuilder str = new StringBuilder(32);
str.append("[");
for (int idx = 0; idx < _updateStr.length; idx++) {
if ((updMask & (1 << idx)) != 0) {
str.append(_updateStr[idx]);
str.append(",");
}
}
if (str.length() > 1)
str.setLength(str.length() - 1);
str.append("]");
return str.toString();
}
/**
* Return the file state as a string
*
* @return String
*/
public String toString() {
StringBuffer str = new StringBuffer();
str.append("[");
str.append(getPath());
str.append(",");
str.append(getFileStatus().name());
if (getStatusChangeReason() != ChangeReason.None) {
str.append("(");
str.append(getStatusChangeReason().name());
str.append(")");
}
str.append(":Opn=");
str.append(super.getOpenCount()); // Local open count only
if (getOpenCount() > 0) {
str.append("(shr=");
str.append(getSharedAccess().name());
str.append(",pid=0x");
str.append(Long.toHexString(getProcessId()));
str.append(")");
}
str.append(",Fid=");
str.append(getFileId());
str.append(",Expire=");
str.append(getSecondsToExpire(System.currentTimeMillis()));
str.append(",Sts=");
str.append(getDataStatus().name());
str.append(",Locks=");
str.append(numberOfLocks());
if (hasOpLock()) {
str.append(",OpLock=");
str.append(getOpLock());
}
if (hasDataUpdateInProgress()) {
str.append(",DataUpd=");
str.append(getDataUpdateNode());
}
str.append("]");
return str.toString();
}
}