mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-06-30 18:15:39 +00:00
e31ea91e51
35224: ALF-12038: Remove trailing JSON comma causing IE7 script error
35226: ALF-13401 - Saving PowerPoint (mac 2011) via CIFS fails in Mac OS X Lion
35239: ALF-13409: Further fix to deal with concurrent deletion of a user's site invitations in background
35245: ALF-13281: Enabled use of autocomplete in IE for forms runtime. This change also allows multiple events to be attached per validation handler
35253: ALF-13640: Fixed issues with updating task associations + added new test + fixed existing activiti-component-tests
35271: Translation updates (fixes: ALF-13434) - based on EN r35212. (Dutch still to follow)
35281: ALF-13227: Fix CSS for Wiki layout of nested lists
35284: SPANISH: Update from Gloria
35290: More debug + unit test for mac powerpoint shuffle.
35291: Added isTemporary method
35295: ALF-13453 : Remote Code Execution (can create reverse shell).
- Added ability for XMLUtil parse callers to provide an optional array of XMLFilterImpl to be used while parsing.
-Added secureParseXSL methods that automatically install an XMLFilterImpl that causes a parse failure if any insecure namespaces are encountered.
35303: Fix for ALF-12444 Node Browser improvement: Index single node and remove single node from indexes
Part of ALF-13723 SOLR does not include the same query unit tests as lucene
35305: ALF-13723 SOLR does not include the same query unit tests as lucene
- test template
35306: ALF-13723 SOLR does not include the same query unit tests as lucene
- template for creating test cores
35323: ALF-13420: Natural sort on form option labels and improvement for CSS - specifically to address transform action in document details.
35328: ALF-13409: Avoid concurrency issues in unit test tear downs by deleting users before sites. User deletion deletes invitations synchronously. Site deletion deletes invitations concurrently to avoid UI timeouts. The potential to access invitations that are being concurrently deleted still exists, but always did!
35331: ALF-12126: Ensure that DND upload is disabled for users with only consumer access
35335: ALF-13708: Merged V3.4-BUG-FIX (3.4.10) to V4.0-BUG-FIX (4.0.2)
35235: ALF-13673: Amp-loaded duplicated mimetypes should be handled
- Modified code to allow duplicates to replace parts of the existing mimetype definitions.
- A warning is logged each time.
35336: Spanish and Dutch updates from Gloria, based on EN r35212
35355: Merged V3.4-BUG-FIX to V4.0-BUG-FIX
35213: ALF-13686: Merged PATCHES/V3.4.8 to V3.4-BUG-FIX
34943: ALF-13121: Option to create users either as user1 or user1@domain.com after kerberos authentication
- New Kerberos subsystem parameter kerberos.authentication.stripUsernameSuffix introduced
- When true (the default) the @domain sufix will be stripped from Kerberos authenticated usernames in CIFS, SPP, WebDAV and the Web Client
- When false, should enable a multi-domain customer to use Alfresco (says Mr Gninot)
35096: ALF-13121: Added missing stripKerberosUsernameSuffix property to sharepointAuthenticationHandler
35215: ALF-13065: Ensure Wiki new page save button is available on HTML edit action
35219: ALF-11898: Fixed TinyMCE create HTML content problem for Explorer client
35261: Translation updates based on EN r35144
35339: AD 2008 R2, user import via LDAP fails with over 1000 users
- Problem discovered by Community user with simple workaround
https://forums.alfresco.com/en/viewtopic.php?f=57&t=43960&sid=5569e5cfbccb3776e11ef4a8e9d50378&p=129664#p129664
35353: Merged V3.4 to V3.4-BUG-FIX
35279: ALF-13713: Merged PATCHES/V3.4.8 to V3.4
35146: Merged DEV to PATCHES/V3.4.8
35130: ALF-13472: Webdav Does not allow a user to access spaces without read permission on parent spaces
Receiving of indirect lock is wrapped into AuthenticationUtil.runAs() invocation to provide a possibility of getting indirect lock for users with appropriate access rights for requested resource
35280: ALF-10353: Internet Explorer hangs when using the object picker with a larger number of documents
- reviewed by DD
35318: ALF-13715: Merged HEAD to V3.4
31743: Fixed ALF-10157: Web Form Details page for the "Selected Web Content Forms": script error appears on help button click: container.jsp (line 382)
35341: ALF-13552: Merged V4.0 to V3.4
35296: ALF-13453: Remote Code Execution (can create reverse shell) - Fix by Shane
35304: ALF-13453: Extra fix to ensure xalan namespace isn't declared with global scope and can't be hijacked by an input stylesheet
35307: ALF-13453: Duplicated extra fix to duplicate code in XSLTRenderingEngine!
35354: Merged V3.4 to V3.4-BUG-FIX (RECORD ONLY)
35266: Merged V3.4-BUG-FIX to V3.4
35261: Translation updates based on EN r35144
35334: Merged V3.4-BUG-FIX to V3.4
35235: ALF-13673: Amp-loaded duplicated mimetypes should be handled
- Modified code to allow duplicates to replace parts of the existing mimetype definitions.
- A warning is logged each time.
35356: Merged V4.0 to V4.0-BUG-FIX
35292: ALF-13721: Merged PATCHES/V4.0.0 to V4.0
35240: Fix for ALF-13685 The SOLr textContent webscript is not protected by authentication and permission checks.
35242: Fix for ALF-13685 The SOLr textContent webscript is not protected by authentication and permission checks.
- /wcs/api/solr and /wcservice/api/solr
35304: ALF-13453: Extra fix to ensure xalan namespace isn't declared with global scope and can't be hijacked by an input stylesheet
35307: ALF-13453: Duplicated extra fix to duplicate code in XSLTRenderingEngine!
35357: Merged V4.0 to V4.0-BUG-FIX (RECORD ONLY)
35048: Merged V4.0-BUG-FIX to V4.0
35031: Fix for ALF-12309: Script errors on site pages
35293: Merged V4.0-BUG-FIX to V4.0
35172: ALF-13626: category.put.json.ftl has wrong bracket
35296: Merged V4.0-BUG-FIX to V4.0
35295: ALF-13453: Remote Code Execution (can create reverse shell)
- Fix by Shane
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@35359 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
2938 lines
102 KiB
Java
2938 lines
102 KiB
Java
/*
|
|
* Copyright (C) 2005-2010 Alfresco Software Limited.
|
|
*
|
|
* 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 <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package org.alfresco.filesys.repo;
|
|
|
|
import java.io.BufferedInputStream;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.Serializable;
|
|
import java.net.InetAddress;
|
|
import java.nio.charset.Charset;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import org.alfresco.error.AlfrescoRuntimeException;
|
|
import org.alfresco.filesys.alfresco.AlfrescoContext;
|
|
import org.alfresco.filesys.alfresco.AlfrescoDiskDriver;
|
|
import org.alfresco.filesys.alfresco.ExtendedDiskInterface;
|
|
import org.alfresco.filesys.alfresco.PseudoFileOverlayImpl;
|
|
import org.alfresco.filesys.alfresco.RepositoryDiskInterface;
|
|
import org.alfresco.jlan.server.SrvSession;
|
|
import org.alfresco.jlan.server.core.DeviceContext;
|
|
import org.alfresco.jlan.server.core.DeviceContextException;
|
|
import org.alfresco.jlan.server.filesys.AccessDeniedException;
|
|
import org.alfresco.jlan.server.filesys.AccessMode;
|
|
import org.alfresco.jlan.server.filesys.DirectoryNotEmptyException;
|
|
import org.alfresco.jlan.server.filesys.DiskDeviceContext;
|
|
import org.alfresco.jlan.server.filesys.DiskFullException;
|
|
import org.alfresco.jlan.server.filesys.DiskInterface;
|
|
import org.alfresco.jlan.server.filesys.DiskSizeInterface;
|
|
import org.alfresco.jlan.server.filesys.FileAttribute;
|
|
import org.alfresco.jlan.server.filesys.FileExistsException;
|
|
import org.alfresco.jlan.server.filesys.FileInfo;
|
|
import org.alfresco.jlan.server.filesys.FileName;
|
|
import org.alfresco.jlan.server.filesys.FileOpenParams;
|
|
import org.alfresco.jlan.server.filesys.FileStatus;
|
|
import org.alfresco.jlan.server.filesys.IOControlNotImplementedException;
|
|
import org.alfresco.jlan.server.filesys.IOCtlInterface;
|
|
import org.alfresco.jlan.server.filesys.NetworkFile;
|
|
import org.alfresco.jlan.server.filesys.PermissionDeniedException;
|
|
import org.alfresco.jlan.server.filesys.SearchContext;
|
|
import org.alfresco.jlan.server.filesys.SrvDiskInfo;
|
|
import org.alfresco.jlan.server.filesys.TreeConnection;
|
|
import org.alfresco.jlan.server.filesys.cache.FileState;
|
|
import org.alfresco.jlan.server.filesys.pseudo.PseudoFile;
|
|
import org.alfresco.jlan.server.filesys.pseudo.PseudoFileList;
|
|
import org.alfresco.jlan.server.filesys.pseudo.PseudoNetworkFile;
|
|
import org.alfresco.jlan.server.filesys.quota.QuotaManager;
|
|
import org.alfresco.jlan.server.filesys.quota.QuotaManagerException;
|
|
import org.alfresco.jlan.server.locking.FileLockingInterface;
|
|
import org.alfresco.jlan.server.locking.LockManager;
|
|
import org.alfresco.jlan.server.locking.OpLockInterface;
|
|
import org.alfresco.jlan.server.locking.OpLockManager;
|
|
import org.alfresco.jlan.smb.SMBException;
|
|
import org.alfresco.jlan.smb.SMBStatus;
|
|
import org.alfresco.jlan.smb.server.SMBServer;
|
|
import org.alfresco.jlan.util.DataBuffer;
|
|
import org.alfresco.jlan.util.MemorySize;
|
|
import org.alfresco.model.ContentModel;
|
|
import org.alfresco.repo.content.MimetypeMap;
|
|
import org.alfresco.repo.content.encoding.ContentCharsetFinder;
|
|
import org.alfresco.repo.content.filestore.FileContentReader;
|
|
import org.alfresco.repo.policy.BehaviourFilter;
|
|
import org.alfresco.repo.security.authentication.AuthenticationContext;
|
|
import org.alfresco.repo.security.authentication.AuthenticationUtil;
|
|
import org.alfresco.repo.security.authentication.AuthenticationUtil.RunAsWork;
|
|
import org.alfresco.service.cmr.coci.CheckOutCheckInService;
|
|
import org.alfresco.service.cmr.lock.LockService;
|
|
import org.alfresco.service.cmr.lock.NodeLockedException;
|
|
import org.alfresco.service.cmr.model.FileFolderService;
|
|
import org.alfresco.service.cmr.repository.ContentData;
|
|
import org.alfresco.service.cmr.repository.ContentIOException;
|
|
import org.alfresco.service.cmr.repository.ContentReader;
|
|
import org.alfresco.service.cmr.repository.ContentService;
|
|
import org.alfresco.service.cmr.repository.ContentWriter;
|
|
import org.alfresco.service.cmr.repository.MimetypeService;
|
|
import org.alfresco.service.cmr.repository.NodeRef;
|
|
import org.alfresco.service.cmr.repository.NodeService;
|
|
import org.alfresco.service.cmr.repository.StoreRef;
|
|
import org.alfresco.service.cmr.repository.datatype.DefaultTypeConverter;
|
|
import org.alfresco.service.cmr.search.SearchService;
|
|
import org.alfresco.service.cmr.security.AccessStatus;
|
|
import org.alfresco.service.cmr.security.AuthenticationService;
|
|
import org.alfresco.service.cmr.security.PermissionService;
|
|
import org.alfresco.service.namespace.NamespaceService;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.util.PropertyCheck;
|
|
import org.alfresco.util.TempFileProvider;
|
|
import org.apache.commons.logging.Log;
|
|
import org.apache.commons.logging.LogFactory;
|
|
import org.springframework.extensions.config.ConfigElement;
|
|
|
|
/**
|
|
* Alfresco Content repository filesystem driver class
|
|
* <p>
|
|
* Provides a JLAN ContentDiskDriver for various JLAN protocols
|
|
* such as SMB/CIFS, NFS and FTP.
|
|
*
|
|
*/
|
|
public class ContentDiskDriver2 extends AlfrescoDiskDriver implements ExtendedDiskInterface,
|
|
DiskInterface,
|
|
DiskSizeInterface,
|
|
IOCtlInterface,
|
|
RepositoryDiskInterface,
|
|
OpLockInterface,
|
|
FileLockingInterface
|
|
{
|
|
// Logging
|
|
private static final Log logger = LogFactory.getLog(ContentDiskDriver2.class);
|
|
|
|
private static final Log readLogger = LogFactory.getLog("org.alfresco.filesys.repo.ContentDiskDriver2.Read");
|
|
private static final Log writeLogger = LogFactory.getLog("org.alfresco.filesys.repo.ContentDiskDriver2.Write");
|
|
|
|
// Services and helpers
|
|
private CifsHelper cifsHelper;
|
|
private NamespaceService namespaceService;
|
|
private NodeService nodeService;
|
|
private SearchService searchService;
|
|
private ContentService contentService;
|
|
private MimetypeService mimetypeService;
|
|
private PermissionService permissionService;
|
|
private FileFolderService fileFolderService;
|
|
private LockService lockService;
|
|
private CheckOutCheckInService checkOutCheckInService;
|
|
private AuthenticationContext authContext;
|
|
private AuthenticationService authService;
|
|
private BehaviourFilter policyBehaviourFilter;
|
|
private NodeMonitorFactory m_nodeMonitorFactory;
|
|
private ContentComparator contentComparator;
|
|
|
|
private boolean isLockedFilesAsOffline;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public void init()
|
|
{
|
|
PropertyCheck.mandatory(this, "checkOutCheckInService", checkOutCheckInService);
|
|
PropertyCheck.mandatory(this, "cifsHelper", cifsHelper);
|
|
PropertyCheck.mandatory(this, "namespaceService", namespaceService);
|
|
PropertyCheck.mandatory(this, "nodeService", nodeService);
|
|
PropertyCheck.mandatory(this, "searchService", searchService);
|
|
PropertyCheck.mandatory(this, "contentService", contentService);
|
|
PropertyCheck.mandatory(this, "mimetypeService", mimetypeService);
|
|
PropertyCheck.mandatory(this, "permissionService", permissionService);
|
|
PropertyCheck.mandatory(this, "fileFolderService", fileFolderService);
|
|
PropertyCheck.mandatory(this, "lockService",lockService);
|
|
PropertyCheck.mandatory(this, "authContext", authContext);
|
|
PropertyCheck.mandatory(this, "authService", authService);
|
|
PropertyCheck.mandatory(this, "policyBehaviourFilter", policyBehaviourFilter);
|
|
PropertyCheck.mandatory(this, "m_nodeMonitorFactory", m_nodeMonitorFactory);
|
|
PropertyCheck.mandatory(this, "ioControlHandler", ioControlHandler);
|
|
PropertyCheck.mandatory(this, "contentComparator", getContentComparator());
|
|
}
|
|
|
|
/**
|
|
* Return the CIFS helper
|
|
*
|
|
* @return CifsHelper
|
|
*/
|
|
public final CifsHelper getCifsHelper()
|
|
{
|
|
return this.cifsHelper;
|
|
}
|
|
|
|
/**
|
|
* Return the authentication service
|
|
*
|
|
* @return AuthenticationService
|
|
*/
|
|
public final AuthenticationService getAuthenticationService()
|
|
{
|
|
return authService;
|
|
}
|
|
|
|
/**
|
|
* Return the authentication context
|
|
*
|
|
* @return AuthenticationContext
|
|
*/
|
|
public final AuthenticationContext getAuthenticationContext() {
|
|
return authContext;
|
|
}
|
|
|
|
/**
|
|
* Return the node service
|
|
*
|
|
* @return NodeService
|
|
*/
|
|
public final NodeService getNodeService()
|
|
{
|
|
return this.nodeService;
|
|
}
|
|
|
|
/**
|
|
* Return the content service
|
|
*
|
|
* @return ContentService
|
|
*/
|
|
public final ContentService getContentService()
|
|
{
|
|
return this.contentService;
|
|
}
|
|
|
|
/**
|
|
* Return the namespace service
|
|
*
|
|
* @return NamespaceService
|
|
*/
|
|
public final NamespaceService getNamespaceService()
|
|
{
|
|
return this.namespaceService;
|
|
}
|
|
|
|
/**
|
|
* Return the search service
|
|
*
|
|
* @return SearchService
|
|
*/
|
|
public final SearchService getSearchService(){
|
|
return this.searchService;
|
|
}
|
|
|
|
/**
|
|
* Return the file folder service
|
|
*
|
|
* @return FileFolderService
|
|
*/
|
|
public final FileFolderService getFileFolderService() {
|
|
return this.fileFolderService;
|
|
}
|
|
|
|
/**
|
|
* Return the permission service
|
|
*
|
|
* @return PermissionService
|
|
*/
|
|
public final PermissionService getPermissionService() {
|
|
return this.permissionService;
|
|
}
|
|
|
|
/**
|
|
* Return the lock service
|
|
*
|
|
* @return LockService
|
|
*/
|
|
public final LockService getLockService() {
|
|
return lockService;
|
|
}
|
|
|
|
/**
|
|
* Get the policy behaviour filter, used to inhibit versioning on a per transaction basis
|
|
*/
|
|
public BehaviourFilter getPolicyFilter()
|
|
{
|
|
return policyBehaviourFilter;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param contentService the content service
|
|
*/
|
|
public void setContentService(ContentService contentService)
|
|
{
|
|
this.contentService = contentService;
|
|
}
|
|
|
|
/**
|
|
* @param namespaceService the namespace service
|
|
*/
|
|
public void setNamespaceService(NamespaceService namespaceService)
|
|
{
|
|
this.namespaceService = namespaceService;
|
|
}
|
|
|
|
/**
|
|
* @param nodeService the node service
|
|
*/
|
|
public void setNodeService(NodeService nodeService)
|
|
{
|
|
this.nodeService = nodeService;
|
|
}
|
|
|
|
/**
|
|
* @param searchService the search service
|
|
*/
|
|
public void setSearchService(SearchService searchService)
|
|
{
|
|
this.searchService = searchService;
|
|
}
|
|
|
|
/**
|
|
* Set the permission service
|
|
*
|
|
* @param permissionService PermissionService
|
|
*/
|
|
public void setPermissionService(PermissionService permissionService)
|
|
{
|
|
this.permissionService = permissionService;
|
|
}
|
|
|
|
/**
|
|
* Set the authentication context
|
|
*
|
|
* @param authContext AuthenticationContext
|
|
*/
|
|
public void setAuthenticationContext(AuthenticationContext authContext)
|
|
{
|
|
this.authContext = authContext;
|
|
}
|
|
|
|
/**
|
|
* Set the authentication service
|
|
*
|
|
* @param authService AuthenticationService
|
|
*/
|
|
public void setAuthenticationService(AuthenticationService authService)
|
|
{
|
|
this.authService = authService;
|
|
}
|
|
|
|
/**
|
|
* Set the file folder service
|
|
*
|
|
* @param fileService FileFolderService
|
|
*/
|
|
public void setFileFolderService(FileFolderService fileService)
|
|
{
|
|
fileFolderService = fileService;
|
|
}
|
|
|
|
/**
|
|
* @param mimetypeService service for helping with mimetypes and encoding
|
|
*/
|
|
public void setMimetypeService(MimetypeService mimetypeService)
|
|
{
|
|
this.mimetypeService = mimetypeService;
|
|
}
|
|
|
|
/**
|
|
* Set the node monitor factory
|
|
*
|
|
* @param nodeMonitorFactory NodeMonitorFactory
|
|
*/
|
|
public void setNodeMonitorFactory(NodeMonitorFactory nodeMonitorFactory) {
|
|
m_nodeMonitorFactory = nodeMonitorFactory;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the lock service
|
|
*
|
|
* @param lockService LockService
|
|
*/
|
|
public void setLockService(LockService lockService) {
|
|
this.lockService = lockService;
|
|
}
|
|
|
|
/**
|
|
* Set the policy behaviour filter, used to inhibit versioning on a per transaction basis
|
|
*
|
|
* @param policyFilter PolicyBehaviourFilter
|
|
*/
|
|
public void setPolicyFilter(BehaviourFilter policyFilter)
|
|
{
|
|
this.policyBehaviourFilter = policyFilter;
|
|
}
|
|
|
|
// Configuration key names
|
|
|
|
private static final String KEY_STORE = "store";
|
|
private static final String KEY_ROOT_PATH = "rootPath";
|
|
private static final String KEY_RELATIVE_PATH = "relativePath";
|
|
|
|
/**
|
|
* Parse and validate the parameter string and create a device context object for this instance
|
|
* of the shared device. The same DeviceInterface implementation may be used for multiple
|
|
* shares.
|
|
* <p>
|
|
* @deprecated - no longer used. Construction of context is via spring now.
|
|
* @param deviceName The name of the device
|
|
* @param cfg ConfigElement the configuration of the device context.
|
|
* @return DeviceContext
|
|
* @exception DeviceContextException
|
|
*/
|
|
public DeviceContext createContext(String deviceName, ConfigElement cfg) throws DeviceContextException
|
|
{
|
|
logger.error("Obsolete method called");
|
|
throw new DeviceContextException("Obsolete Method called");
|
|
}
|
|
|
|
/*
|
|
* Register context implementation
|
|
* <p>
|
|
* Results in various obscure bits and pieces being initialised, most importantly the
|
|
* calculation of the root node ref.
|
|
* <p>
|
|
* There's a load of initialisation that needs to be moved out of this method, like the
|
|
* instantiation of the lock manager, quota manager and node monitor.
|
|
*/
|
|
public void registerContext(DeviceContext ctx) throws DeviceContextException
|
|
{
|
|
logger.debug("registerContext");
|
|
super.registerContext(ctx);
|
|
|
|
final ContentContext context = (ContentContext)ctx;
|
|
|
|
final String rootPath = context.getRootPath();
|
|
final String storeValue = context.getStoreName();
|
|
|
|
/**
|
|
* Work using the repo needs to run as system.
|
|
*/
|
|
RunAsWork<Void> runAsSystem = new RunAsWork<Void>()
|
|
{
|
|
@Override
|
|
public Void doWork() throws Exception
|
|
{
|
|
StoreRef storeRef = new StoreRef(storeValue);
|
|
|
|
// Connect to the repo and ensure that the store exists
|
|
|
|
if (! nodeService.exists(storeRef))
|
|
{
|
|
throw new DeviceContextException("Store not created prior to application startup: " + storeRef);
|
|
}
|
|
|
|
NodeRef storeRootNodeRef = nodeService.getRootNode(storeRef);
|
|
|
|
// Find the root node for this device
|
|
List<NodeRef> nodeRefs = searchService.selectNodes(storeRootNodeRef, rootPath, null, namespaceService, false);
|
|
|
|
NodeRef rootNodeRef = null;
|
|
|
|
if (nodeRefs.size() > 1)
|
|
{
|
|
throw new DeviceContextException("Multiple possible roots for device: \n" +
|
|
" root path: " + rootPath + "\n" +
|
|
" results: " + nodeRefs);
|
|
}
|
|
else if (nodeRefs.size() == 0)
|
|
{
|
|
// Nothing found
|
|
throw new DeviceContextException("No root found for device: \n" +
|
|
" root path: " + rootPath);
|
|
}
|
|
else
|
|
{
|
|
// We found the root node ref
|
|
rootNodeRef = nodeRefs.get(0);
|
|
}
|
|
|
|
// Check if a relative path has been specified
|
|
String relPath = context.getRelativePath();
|
|
|
|
try
|
|
{
|
|
if ( relPath != null && relPath.length() > 0)
|
|
{
|
|
// Find the node and validate that the relative path is to a folder
|
|
NodeRef relPathNode = cifsHelper.getNodeRef( rootNodeRef, relPath);
|
|
|
|
if ( cifsHelper.isDirectory( relPathNode) == false)
|
|
{
|
|
throw new DeviceContextException("Relative path is not a folder, " + relPath);
|
|
}
|
|
|
|
// Use the relative path node as the root of the filesystem
|
|
rootNodeRef = relPathNode;
|
|
}
|
|
else
|
|
{
|
|
// Make sure the default root node is a folder
|
|
if ( cifsHelper.isDirectory( rootNodeRef) == false)
|
|
{
|
|
throw new DeviceContextException("Root node is not a folder type node");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Error during create context", ex);
|
|
}
|
|
throw new DeviceContextException("Unable to find root node.", ex);
|
|
}
|
|
|
|
// Record the root node ref
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("set root node ref:" + rootNodeRef);
|
|
}
|
|
context.setRootNodeRef(rootNodeRef);
|
|
|
|
return null;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Run the above code as system - in particular resolves root node ref.
|
|
*/
|
|
AuthenticationUtil.runAs(runAsSystem, AuthenticationUtil.getSystemUserName());
|
|
|
|
|
|
/*
|
|
* Now we have some odds and ends below that should really be configured elsewhere
|
|
*/
|
|
|
|
// Check if locked files should be marked as offline
|
|
if ( context.getOfflineFiles() )
|
|
{
|
|
// Enable marking locked files as offline
|
|
isLockedFilesAsOffline = true;
|
|
logger.info("Locked files will be marked as offline");
|
|
}
|
|
|
|
// Enable file state caching
|
|
|
|
// context.enableStateCache(serverConfig, true);
|
|
// context.getStateCache().setCaseSensitive( false);
|
|
|
|
logger.debug("initialise the node monitor");
|
|
// Install the node service monitor
|
|
if ( !context.getDisableNodeMonitor() && m_nodeMonitorFactory != null)
|
|
{
|
|
NodeMonitor nodeMonitor = m_nodeMonitorFactory.createNodeMonitor(context);
|
|
context.setNodeMonitor( nodeMonitor);
|
|
}
|
|
|
|
logger.debug("initialise the file state lock manager");
|
|
|
|
|
|
// Check if oplocks are enabled
|
|
|
|
if ( context.getDisableOplocks() == true)
|
|
{
|
|
logger.warn("Oplock support disabled for filesystem " + context.getDeviceName());
|
|
}
|
|
|
|
// Start the quota manager, if enabled
|
|
if ( context.hasQuotaManager())
|
|
{
|
|
try
|
|
{
|
|
// Start the quota manager
|
|
context.getQuotaManager().startManager( this, context);
|
|
logger.info("Quota manager enabled for filesystem");
|
|
}
|
|
catch ( QuotaManagerException ex)
|
|
{
|
|
logger.error("Failed to start quota manager", ex);
|
|
}
|
|
}
|
|
|
|
// TODO mode to spring
|
|
PseudoFileOverlayImpl ps = new PseudoFileOverlayImpl();
|
|
ps.setContext(context);
|
|
ps.setNodeService(nodeService);
|
|
ps.setSysAdminParams(context.getSysAdminParams());
|
|
context.setPseudoFileOverlay(ps);
|
|
ps.init();
|
|
}
|
|
|
|
/**
|
|
* Determine if the disk device is read-only.
|
|
*
|
|
* @param sess Server session
|
|
* @param ctx Device context
|
|
* @return boolean
|
|
* @exception java.io.IOException If an error occurs.
|
|
*/
|
|
public boolean isReadOnly(SrvSession sess, DeviceContext ctx) throws IOException
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("isReadOnly");
|
|
}
|
|
return !m_transactionService.getAllowWrite();
|
|
}
|
|
|
|
/**
|
|
* Get the file information for the specified file.
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param name File name/path that information is required for.
|
|
* @return File information if valid, else null
|
|
* @exception java.io.IOException The exception description.
|
|
*/
|
|
public FileInfo getFileInformation(SrvSession session, TreeConnection tree, String path) throws IOException
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("getFileInformation:" + path + ", session:" + session.getUniqueId());
|
|
}
|
|
ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
if ( path == null || path.length() == 0)
|
|
{
|
|
path = FileName.DOS_SEPERATOR_STR;
|
|
}
|
|
|
|
String infoPath = path;
|
|
|
|
try
|
|
{
|
|
FileInfo finfo = null;
|
|
|
|
// Is the node a pseudo file ?
|
|
if(session.isPseudoFilesEnabled() && ctx.isPseudoFilesEnabled())
|
|
{
|
|
String[] paths = FileName.splitPath(path);
|
|
// lookup parent directory
|
|
NodeRef dirNodeRef = getNodeForPath(tree, paths[0]);
|
|
|
|
// Check whether we are opening a pseudo file
|
|
if(ctx.getPseudoFileOverlay().isPseudoFile(dirNodeRef, paths[1]))
|
|
{
|
|
PseudoFile pfile = ctx.getPseudoFileOverlay().getPseudoFile(dirNodeRef, paths[1]);
|
|
FileInfo pseudoFileInfo = pfile.getFileInfo();
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("returning psuedo file details:" + pseudoFileInfo);
|
|
}
|
|
return pseudoFileInfo;
|
|
}
|
|
}
|
|
|
|
// no - this is not a specially named pseudo file.
|
|
NodeRef nodeRef = getNodeForPath(tree, infoPath);
|
|
|
|
if ( nodeRef != null)
|
|
{
|
|
// Get the file information for the node
|
|
|
|
finfo = getCifsHelper().getFileInformation(nodeRef, false, isLockedFilesAsOffline);
|
|
|
|
/**
|
|
* Special processing for root node
|
|
*/
|
|
if(path.equals(FileName.DOS_SEPERATOR_STR))
|
|
{
|
|
finfo.setFileName("");
|
|
}
|
|
|
|
// DEBUG
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("getFileInformation found nodeRef for nodeRef :"+ nodeRef + ", path: " + path);
|
|
}
|
|
|
|
// Moved to CIFS Helper
|
|
// // Set the file id from the node's DBID
|
|
// long id = DefaultTypeConverter.INSTANCE.convert(Long.class, nodeService.getProperty(nodeRef, ContentModel.PROP_NODE_DBID));
|
|
// finfo.setFileId((int) (id & 0xFFFFFFFFL));
|
|
}
|
|
|
|
// Return the file information or null if the node ref does not exist
|
|
return finfo;
|
|
}
|
|
catch (FileNotFoundException e)
|
|
{
|
|
// Debug
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
// exception not logged - cifs does lots of these
|
|
logger.debug("Get file info - file not found, " + path);
|
|
}
|
|
throw e;
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Get file info - access denied, " + path, ex);
|
|
}
|
|
|
|
// Convert to a filesystem access denied status
|
|
throw new AccessDeniedException("Get file information " + path);
|
|
}
|
|
catch (AlfrescoRuntimeException ex)
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Get file info error" + path, ex);
|
|
}
|
|
|
|
// Convert to a general I/O exception
|
|
throw new IOException("Get file information " + path, ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Start a new search on the filesystem using the specified searchPath that may contain
|
|
* wildcards.
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param searchPath File(s) to search for, may include wildcards.
|
|
* @param attrib Attributes of the file(s) to search for, see class SMBFileAttribute.
|
|
* @return SearchContext
|
|
* @exception java.io.FileNotFoundException If the search could not be started.
|
|
*/
|
|
public SearchContext startSearch(SrvSession session, TreeConnection tree, String searchPath, int attributes) throws FileNotFoundException
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("startSearch: "+ searchPath + ", session:" + session.getUniqueId());
|
|
}
|
|
// Access the device context
|
|
|
|
ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
try
|
|
{
|
|
String searchFileSpec = searchPath;
|
|
|
|
NodeRef searchRootNodeRef = ctx.getRootNode();
|
|
|
|
String[] paths = FileName.splitPath(searchPath);
|
|
String dotPath = paths[0];
|
|
|
|
// lookup parent directory
|
|
NodeRef dirNodeRef = getNodeForPath(tree, dotPath);
|
|
if(dirNodeRef != null)
|
|
{
|
|
searchRootNodeRef = dirNodeRef;
|
|
searchFileSpec = paths[1];
|
|
}
|
|
|
|
// Convert the all files wildcard
|
|
if ( searchFileSpec.equals( "*.*"))
|
|
{
|
|
searchFileSpec = "*";
|
|
}
|
|
|
|
// Debug
|
|
long startTime = 0L;
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
startTime = System.currentTimeMillis();
|
|
}
|
|
|
|
// Perform the search
|
|
|
|
logger.debug("Call repo to do search");
|
|
|
|
List<NodeRef> results = getCifsHelper().getNodeRefs(searchRootNodeRef, searchFileSpec);
|
|
// Debug
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
long endTime = System.currentTimeMillis();
|
|
if (( endTime - startTime) > 500)
|
|
{
|
|
logger.debug("Search for searchPath=" + searchPath + ", searchSpec=" + searchFileSpec + ", searchRootNode=" + searchRootNodeRef + " took "
|
|
+ ( endTime - startTime) + "ms results=" + results.size());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Search pseudo files if they are enabled
|
|
*/
|
|
PseudoFileList pseudoList = null;
|
|
if(session.isPseudoFilesEnabled() && ctx.isPseudoFilesEnabled())
|
|
{
|
|
logger.debug("search pseudo files");
|
|
pseudoList = ctx.getPseudoFileOverlay().searchPseudoFiles(dirNodeRef, searchFileSpec);
|
|
}
|
|
|
|
DotDotContentSearchContext searchCtx = new DotDotContentSearchContext(getCifsHelper(), results, searchFileSpec, pseudoList, paths[0]);
|
|
|
|
FileInfo dotInfo = getCifsHelper().getFileInformation(searchRootNodeRef, false, isLockedFilesAsOffline);
|
|
|
|
if ( searchPath.equals( FileName.DOS_SEPERATOR_STR)) {
|
|
// Searching the root folder, re-use the search folder file information for the '..' pseudo entry
|
|
FileInfo dotDotInfo = new FileInfo();
|
|
dotDotInfo.copyFrom(dotInfo);
|
|
searchCtx.setDotInfo(dotInfo);
|
|
searchCtx.setDotDotInfo( dotDotInfo);
|
|
}
|
|
else
|
|
{
|
|
String[] parent = FileName.splitPath(dotPath);
|
|
NodeRef parentNodeRef = getNodeForPath(tree, parent[0]);
|
|
if(parentNodeRef != null)
|
|
{
|
|
FileInfo dotDotInfo = getCifsHelper().getFileInformation(parentNodeRef, false, isLockedFilesAsOffline);
|
|
searchCtx.setDotDotInfo(dotDotInfo);
|
|
}
|
|
|
|
// Searching a normal, non root, folder
|
|
// Need to set dot and dotdot
|
|
searchCtx.setDotInfo(dotInfo);
|
|
|
|
}
|
|
|
|
// Debug
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Started search: search path=" + searchPath + " attributes=" + attributes + ", ctx=" + searchCtx);
|
|
}
|
|
|
|
// TODO --
|
|
// Need to resolve the file info here so it's within the transaction boundary.
|
|
|
|
return searchCtx;
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Start search - access denied, " + searchPath);
|
|
}
|
|
|
|
// Convert to a file not found status
|
|
|
|
throw new FileNotFoundException("Start search " + searchPath);
|
|
}
|
|
catch (AlfrescoRuntimeException ex)
|
|
{
|
|
// This is an error even though we "handle" it here.
|
|
|
|
if ( logger.isErrorEnabled())
|
|
{
|
|
logger.error("Exception in Start search", ex);
|
|
}
|
|
|
|
// Convert to a file not found status
|
|
|
|
throw new FileNotFoundException("Start search " + searchPath);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if the specified file exists, and whether it is a file or directory.
|
|
*
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param name the path of the file
|
|
* @return FileStatus (0: NotExist, 1 : FileExist, 2: DirectoryExists)
|
|
* @see FileStatus
|
|
*/
|
|
public int fileExists(SrvSession session, TreeConnection tree, String name)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("fileExists:" + name + ", session:" + session.getUniqueId());
|
|
}
|
|
ContentContext ctx = (ContentContext) tree.getContext();
|
|
int status = FileStatus.Unknown;
|
|
try
|
|
{
|
|
if(session.isPseudoFilesEnabled() && ctx.isPseudoFilesEnabled())
|
|
{
|
|
String[] paths = FileName.splitPath(name);
|
|
// lookup parent directory
|
|
NodeRef dirNodeRef = getNodeForPath(tree, paths[0]);
|
|
// Check whether we are opening a pseudo file
|
|
if(ctx.getPseudoFileOverlay().isPseudoFile(dirNodeRef, paths[1]))
|
|
{
|
|
return FileStatus.FileExists;
|
|
}
|
|
}
|
|
|
|
// Get the file information to check if the file/folder exists
|
|
FileInfo info = getFileInformation(session, tree, name);
|
|
if (info.isDirectory())
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("is directory");
|
|
}
|
|
status = FileStatus.DirectoryExists;
|
|
}
|
|
else
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("is file");
|
|
}
|
|
status = FileStatus.FileExists;
|
|
}
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("File status determined: name=" + name + " status=" + status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
catch (FileNotFoundException e)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("file does not exist");
|
|
}
|
|
status = FileStatus.NotExist;
|
|
return status;
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("File exists error, " + name, e);
|
|
}
|
|
|
|
status = FileStatus.NotExist;
|
|
return status;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Open a file or folder - obsolete implementation.
|
|
*
|
|
* @param sess SrvSession
|
|
* @param tree TreeConnection
|
|
* @param params FileOpenParams
|
|
* @return NetworkFile
|
|
* @exception IOException
|
|
*/
|
|
public NetworkFile openFile(SrvSession session, TreeConnection tree, FileOpenParams params) throws IOException
|
|
{
|
|
// obsolete
|
|
logger.error("Obsolete method called");
|
|
throw new AlfrescoRuntimeException("obsolete method called");
|
|
}
|
|
|
|
/**
|
|
* Create a new file on the file system.
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param params File create parameters
|
|
* @return NetworkFile
|
|
* @exception java.io.IOException If an error occurs.
|
|
*/
|
|
public NetworkFile createFile(SrvSession sess, final TreeConnection tree, final FileOpenParams params) throws IOException
|
|
{
|
|
// Obsolete
|
|
logger.error("Obsolete method called");
|
|
throw new AlfrescoRuntimeException("obsolete method called");
|
|
}
|
|
|
|
/**
|
|
* Create a new directory on this file system.
|
|
*
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection.
|
|
* @param params Directory create parameters
|
|
* @exception java.io.IOException If an error occurs.
|
|
*/
|
|
public void createDirectory(SrvSession sess, final TreeConnection tree, final FileOpenParams params) throws IOException
|
|
{
|
|
final ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("createDirectory :" + params);
|
|
}
|
|
|
|
try
|
|
{
|
|
NodeRef dirNodeRef;
|
|
String folderName;
|
|
|
|
String path = params.getPath();
|
|
|
|
String[] paths = FileName.splitPath(path);
|
|
|
|
if (paths[0] != null && paths[0].length() > 1)
|
|
{
|
|
// lookup parent directory
|
|
dirNodeRef = getNodeForPath(tree, paths[0]);
|
|
folderName = paths[1];
|
|
}
|
|
else
|
|
{
|
|
dirNodeRef = ctx.getRootNode();
|
|
folderName = path;
|
|
}
|
|
|
|
if(dirNodeRef == null)
|
|
{
|
|
throw new IOException("Create directory parent folder not found" + params.getFullPath());
|
|
}
|
|
|
|
NodeRef nodeRef = getCifsHelper().createNode(dirNodeRef, folderName, ContentModel.TYPE_FOLDER);
|
|
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Created directory: path=" + params.getPath() + " file open params=" + params + " node=" + nodeRef);
|
|
}
|
|
|
|
// void return
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Create directory - access denied, " + params.getFullPath());
|
|
}
|
|
// Convert to a filesystem access denied status
|
|
|
|
throw new AccessDeniedException("Create directory " + params.getFullPath());
|
|
}
|
|
catch (AlfrescoRuntimeException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Create directory error", ex);
|
|
}
|
|
|
|
// Convert to a general I/O exception
|
|
|
|
throw new IOException("Create directory " + params.getFullPath(), ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete the directory from the filesystem.
|
|
* <p>
|
|
* The directory must be empty in order to be able to delete ity
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param dir Directory name.
|
|
* @exception java.io.IOException The exception description.
|
|
*/
|
|
public void deleteDirectory(SrvSession session, TreeConnection tree, final String dir) throws IOException
|
|
{
|
|
// get the device root
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("deleteDirectory: " + dir + ", session:" + session.getUniqueId());
|
|
}
|
|
|
|
ContentContext ctx = (ContentContext) tree.getContext();
|
|
final NodeRef deviceRootNodeRef = ctx.getRootNode();
|
|
|
|
try
|
|
{
|
|
// Get the node for the folder
|
|
|
|
NodeRef nodeRef = getCifsHelper().getNodeRef(deviceRootNodeRef, dir);
|
|
if (fileFolderService.exists(nodeRef))
|
|
{
|
|
// Check if the folder is empty
|
|
|
|
if ( getCifsHelper().isFolderEmpty( nodeRef))
|
|
{
|
|
// Delete the folder node
|
|
fileFolderService.delete(nodeRef);
|
|
}
|
|
else
|
|
{
|
|
throw new DirectoryNotEmptyException( dir);
|
|
}
|
|
}
|
|
|
|
// Debug
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Deleted directory: directory=" + dir + " node=" + nodeRef);
|
|
}
|
|
// void return
|
|
}
|
|
catch (FileNotFoundException e)
|
|
{
|
|
// Debug
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Delete directory - file not found, " + dir);
|
|
}
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Delete directory - access denied, " + dir);
|
|
}
|
|
// Convert to a filesystem access denied status
|
|
|
|
throw new AccessDeniedException("Delete directory, access denied :" + dir);
|
|
}
|
|
catch (AlfrescoRuntimeException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled() && ctx.hasDebug(AlfrescoContext.DBG_FILE))
|
|
logger.debug("Delete directory", ex);
|
|
|
|
// Convert to a general I/O exception
|
|
|
|
throw new IOException("Delete directory " + dir, ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flush any buffered output for the specified file.
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param file Network file context.
|
|
* @exception java.io.IOException The exception description.
|
|
*/
|
|
public void flushFile(SrvSession session, TreeConnection tree, NetworkFile file) throws IOException
|
|
{
|
|
// Debug
|
|
|
|
ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Flush file=" + file.getFullName()+ ", session:" + session.getUniqueId());
|
|
}
|
|
|
|
// Flush the file data
|
|
file.flushFile();
|
|
}
|
|
|
|
/**
|
|
* Close the file.
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection.
|
|
* @param param Network file context.
|
|
*
|
|
* @exception java.io.IOException If an error occurs.
|
|
*/
|
|
public void closeFile(SrvSession session, TreeConnection tree, final NetworkFile file) throws IOException
|
|
{
|
|
throw new AlfrescoRuntimeException("obsolete method called");
|
|
}
|
|
|
|
/**
|
|
* Delete the specified file.
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param file NetworkFile
|
|
* @exception java.io.IOException The exception description.
|
|
*/
|
|
public void deleteFile(final SrvSession session, final TreeConnection tree, final String name) throws IOException
|
|
{
|
|
// Get the device context
|
|
|
|
final ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("deleteFile:" + name + ", session:" + session.getUniqueId());
|
|
}
|
|
|
|
try
|
|
{
|
|
if(session.isPseudoFilesEnabled() && ctx.isPseudoFilesEnabled())
|
|
{
|
|
String[] paths = FileName.splitPath(name);
|
|
// lookup parent directory
|
|
NodeRef dirNodeRef = getNodeForPath(tree, paths[0]);
|
|
|
|
// Check whether we are opening a pseudo file
|
|
if(ctx.getPseudoFileOverlay().isPseudoFile(dirNodeRef, paths[1]))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Check if there is a quota manager enabled, if so then we need to save the current file size
|
|
|
|
final QuotaManager quotaMgr = ctx.getQuotaManager();
|
|
|
|
// Get the node and delete it
|
|
final NodeRef nodeRef = getNodeForPath(tree, name);
|
|
|
|
if (fileFolderService.exists(nodeRef))
|
|
{
|
|
// Get the size of the file being deleted
|
|
final FileInfo fInfo = quotaMgr == null ? null : getFileInformation(session, tree, name);
|
|
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("deleted file" + name);
|
|
}
|
|
fileFolderService.delete(nodeRef);
|
|
|
|
//TODO Needs to be post-commit
|
|
if (quotaMgr != null)
|
|
{
|
|
quotaMgr.releaseSpace(session, tree, fInfo.getFileId(), name, fInfo.getSize());
|
|
}
|
|
|
|
// Debug
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Deleted file: " + name + ", nodeRef=" + nodeRef);
|
|
}
|
|
|
|
// void return
|
|
return;
|
|
}
|
|
}
|
|
catch (NodeLockedException ex)
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Delete file - access denied (locked)", ex);
|
|
}
|
|
// Convert to a filesystem access denied status
|
|
|
|
throw new AccessDeniedException("Unable to delete " + name);
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Delete file - access denied", ex);
|
|
}
|
|
|
|
// Convert to a filesystem access denied status
|
|
throw new AccessDeniedException("Unable to delete " + name);
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
// Allow I/O Exceptions to pass through
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Delete file error - pass through IO Exception", ex);
|
|
}
|
|
throw ex;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Delete file error", ex);
|
|
}
|
|
|
|
// Convert to a general I/O exception
|
|
IOException ioe = new IOException("Delete file " + name);
|
|
ioe.initCause(ex);
|
|
throw ioe;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rename the specified file.
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param oldName java.lang.String
|
|
* @param newName java.lang.String
|
|
* @exception java.io.IOException The exception description.
|
|
*/
|
|
public void renameFile(final SrvSession session, final TreeConnection tree, final String oldName, final String newName)
|
|
throws IOException
|
|
{
|
|
// Get the device context
|
|
final ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
// DEBUG
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("RenameFile oldName=" + oldName + ", newName=" + newName + ", session:" + session.getUniqueId());
|
|
}
|
|
|
|
try
|
|
{
|
|
// Get the file/folder to move
|
|
|
|
final NodeRef nodeToMoveRef = getNodeForPath(tree, oldName);
|
|
|
|
// Check if the node is a link node
|
|
|
|
if ( nodeToMoveRef != null && nodeService.getProperty(nodeToMoveRef, ContentModel.PROP_LINK_DESTINATION) != null)
|
|
{
|
|
throw new AccessDeniedException("Cannot rename link nodes");
|
|
}
|
|
|
|
// Get the new target folder - it must be a folder
|
|
String[] splitPaths = FileName.splitPath(newName);
|
|
String[] oldPaths = FileName.splitPath(oldName);
|
|
|
|
final NodeRef targetFolderRef = getNodeForPath(tree, splitPaths[0]);
|
|
final NodeRef sourceFolderRef = getNodeForPath(tree, oldPaths[0]);
|
|
final String name = splitPaths[1];
|
|
|
|
// Check if this is a rename within the same folder
|
|
|
|
final boolean sameFolder = splitPaths[0].equalsIgnoreCase(oldPaths[0]);
|
|
|
|
// Check if we are renaming a folder, or the rename is to a different folder
|
|
boolean isFolder = getCifsHelper().isDirectory(nodeToMoveRef);
|
|
|
|
if ( isFolder == true || sameFolder == false) {
|
|
|
|
// Rename or move the file/folder to another folder
|
|
if (sameFolder == true)
|
|
{
|
|
fileFolderService.rename(nodeToMoveRef, name);
|
|
|
|
}
|
|
else
|
|
{
|
|
fileFolderService.moveFrom(nodeToMoveRef, sourceFolderRef, targetFolderRef, name);
|
|
}
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug(" Renamed " + (isFolder ? "folder" : "file") + " using "
|
|
+ (sameFolder ? "rename" : "move"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Rename a file within the same folder
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug(
|
|
"Rename file within same folder: \n" +
|
|
" Old name: " + oldName + "\n" +
|
|
" New name: " + newName + "\n" +
|
|
" Source folder: " + sourceFolderRef + "\n" +
|
|
" Target folder: " + targetFolderRef + "\n" +
|
|
" Node: " + nodeToMoveRef + "\n" +
|
|
" Aspects: " + nodeService.getAspects(nodeToMoveRef));
|
|
}
|
|
fileFolderService.rename(nodeToMoveRef, name);
|
|
|
|
}
|
|
}
|
|
catch (org.alfresco.service.cmr.model.FileNotFoundException e)
|
|
{
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Rename file - about to throw file not exists exception file:" + oldName, e);
|
|
}
|
|
throw new java.io.FileNotFoundException("renameFile: file not found file: + oldName");
|
|
}
|
|
catch (org.alfresco.service.cmr.model.FileExistsException e)
|
|
{
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Rename file - about to throw file exists exception", e);
|
|
}
|
|
throw new org.alfresco.jlan.server.filesys.FileExistsException(newName);
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Rename file - about to throw permissions denied exception", ex);
|
|
}
|
|
throw new org.alfresco.jlan.server.filesys.PermissionDeniedException("renameFile: No permissions to rename file:" + oldName);
|
|
}
|
|
catch (NodeLockedException ex)
|
|
{
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Rename file - about to throw access denied exception", ex);
|
|
}
|
|
// Convert to an filesystem access denied exception
|
|
throw new AccessDeniedException("renameFile: Access Denied - Node locked file:" + oldName);
|
|
}
|
|
catch (AlfrescoRuntimeException ex)
|
|
{
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Rename file about to throw access denied exception", ex);
|
|
}
|
|
throw new AlfrescoRuntimeException("renameFile failed: \n" +
|
|
" Old name: " + oldName + "\n" +
|
|
" New name: " + newName + "\n" +
|
|
ex);
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set file information
|
|
*
|
|
* @param sess SrvSession
|
|
* @param tree TreeConnection
|
|
* @param name String
|
|
* @param info FileInfo
|
|
* @exception IOException
|
|
*/
|
|
public void setFileInformation(SrvSession sess, final TreeConnection tree, final String name, final FileInfo info) throws IOException
|
|
{
|
|
// Get the device context
|
|
|
|
final ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("setFileInformation name=" + name + ", info=" + info);
|
|
}
|
|
|
|
NetworkFile networkFile = info.getNetworkFile();
|
|
|
|
try
|
|
{
|
|
|
|
if(sess.isPseudoFilesEnabled() && ctx.isPseudoFilesEnabled())
|
|
{
|
|
String[] paths = FileName.splitPath(name);
|
|
// lookup parent directory
|
|
NodeRef dirNodeRef = getNodeForPath(tree, paths[0]);
|
|
|
|
// Check whether we are opening a pseudo file
|
|
if(ctx.getPseudoFileOverlay().isPseudoFile(dirNodeRef, paths[1]))
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("pseudo file so do nothing");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Get the file/folder node
|
|
NodeRef nodeRef = getNodeForPath(tree, name);
|
|
|
|
// Check permissions on the file/folder node
|
|
|
|
if ( permissionService.hasPermission(nodeRef, PermissionService.WRITE) == AccessStatus.DENIED)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("write access denied to :" + name);
|
|
}
|
|
throw new AccessDeniedException("No write access to " + name);
|
|
}
|
|
|
|
// Inhibit versioning for this transaction
|
|
getPolicyFilter().disableBehaviour( ContentModel.ASPECT_VERSIONABLE);
|
|
|
|
// Check if the file is being marked for deletion, if so then check if the file is locked
|
|
if ( info.hasSetFlag(FileInfo.SetDeleteOnClose) && info.hasDeleteOnClose())
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set Delete On Close for :" + name);
|
|
}
|
|
// Check for delete permission
|
|
if ( permissionService.hasPermission(nodeRef, PermissionService.DELETE) == AccessStatus.DENIED)
|
|
{
|
|
throw new PermissionDeniedException("No delete access to :" + name);
|
|
}
|
|
|
|
// Check if the node is locked
|
|
lockService.checkForLock(nodeRef);
|
|
|
|
// Get the node for the folder
|
|
|
|
if (fileFolderService.exists(nodeRef))
|
|
{
|
|
// Check if it is a folder that is being deleted, make sure it is empty
|
|
|
|
boolean isFolder = true;
|
|
|
|
ContentFileInfo cInfo = getCifsHelper().getFileInformation(nodeRef, false, isLockedFilesAsOffline);
|
|
|
|
if ( cInfo != null && cInfo.isDirectory() == false)
|
|
{
|
|
isFolder = false;
|
|
}
|
|
|
|
// Check if the folder is empty
|
|
if ( isFolder == true && getCifsHelper().isFolderEmpty( nodeRef) == false)
|
|
{
|
|
throw new DirectoryNotEmptyException( name);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(info.hasSetFlag(FileInfo.SetAttributes))
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set attributes" + name + ", file attrs = " + info.getFileAttributes());
|
|
}
|
|
|
|
//TODO MER Think we may need to implement, Temporary, Hidden, System, Archive
|
|
if(info.isSystem())
|
|
{
|
|
logger.debug("Set system aspect (not yet implemented)" + name);
|
|
}
|
|
if(info.isTemporary())
|
|
{
|
|
logger.debug("Set temporary aspect (not yet implemented)" + name);
|
|
}
|
|
|
|
if(info.isHidden())
|
|
{
|
|
// yes is hidden
|
|
if(!nodeService.hasAspect(nodeRef, ContentModel.ASPECT_HIDDEN))
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set hidden aspect (not yet implemented)" + name);
|
|
}
|
|
// TODO Not yet implemented - and how to reset hidden bit?
|
|
// nodeService.addAspect(nodeRef, ContentModel.ASPECT_HIDDEN, null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// not hidden is hidden
|
|
if(nodeService.hasAspect(nodeRef, ContentModel.ASPECT_HIDDEN))
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Reset hidden aspect (not yet implemented)" + name);
|
|
}
|
|
}
|
|
// not hidden
|
|
}
|
|
} // End of setting attributes
|
|
|
|
if( info.hasSetFlag(FileInfo.SetAllocationSize))
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set allocation size" + name + info.getAllocationSize());
|
|
}
|
|
// Not yet implemented
|
|
}
|
|
|
|
if( info.hasSetFlag(FileInfo.SetFileSize))
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set file size" + name + info.getSize());
|
|
}
|
|
// Not yet implemented
|
|
}
|
|
|
|
if( info.hasSetFlag(FileInfo.SetMode))
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set Mode" + name + info.getMode());
|
|
}
|
|
// Not yet implemented - set the unix mode e.g. 777
|
|
}
|
|
|
|
// Set the creation and modified date/time
|
|
Map<QName, Serializable> auditableProps = new HashMap<QName, Serializable>(5);
|
|
|
|
// Which DeleteOnClose flag has priority?
|
|
// SetDeleteOnClose is not set or used in this method.
|
|
// The NTProtocolHandler sets the deleteOnClose in both
|
|
// info and the NetworkFile - it's the one in NetworkFile that works.
|
|
|
|
if ( info.hasSetFlag(FileInfo.SetCreationDate) && info.hasCreationDateTime())
|
|
{
|
|
// Set the creation date on the file/folder node
|
|
Date createDate = new Date(info.getCreationDateTime());
|
|
auditableProps.put(ContentModel.PROP_CREATED, createDate);
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set creation date" + name + ", " + createDate);
|
|
}
|
|
}
|
|
if ( info.hasSetFlag(FileInfo.SetModifyDate) && info.hasModifyDateTime())
|
|
{
|
|
// Set the modification date on the file/folder node
|
|
Date modifyDate = new Date( info.getModifyDateTime());
|
|
auditableProps.put(ContentModel.PROP_MODIFIED, modifyDate);
|
|
|
|
// Set the network file so we don't reverse this change in close file.
|
|
if(networkFile != null && !networkFile.isReadOnly())
|
|
{
|
|
networkFile.setModifyDate(info.getModifyDateTime());
|
|
}
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set modification date" + name + ", " + modifyDate);
|
|
}
|
|
|
|
}
|
|
|
|
// Did we have any cm:auditable properties?
|
|
if (auditableProps.size() > 0)
|
|
{
|
|
getPolicyFilter().disableBehaviour(nodeRef, ContentModel.ASPECT_AUDITABLE);
|
|
nodeService.addProperties(nodeRef, auditableProps);
|
|
|
|
// DEBUG
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set auditable props: " + auditableProps + " file=" + name);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Set file information - access denied, " + name);
|
|
}
|
|
// Convert to a filesystem access denied status
|
|
throw new AccessDeniedException("Set file information " + name);
|
|
}
|
|
catch (AlfrescoRuntimeException ex)
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Open file error", ex);
|
|
}
|
|
// Convert to a general I/O exception
|
|
|
|
throw new IOException("Set file information " + name, ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Truncate a file to the specified size
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param file Network file details
|
|
* @param size New file length
|
|
* @exception java.io.IOException The exception description.
|
|
*/
|
|
public void truncateFile(SrvSession sess, TreeConnection tree, NetworkFile file, long size) throws IOException
|
|
{
|
|
// Keep track of the allocation/release size in case the file resize fails
|
|
|
|
ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("truncateFile file:" + file + ", size: "+ size);
|
|
}
|
|
|
|
long allocSize = 0L;
|
|
long releaseSize = 0L;
|
|
|
|
// Check if there is a quota manager
|
|
QuotaManager quotaMgr = ctx.getQuotaManager();
|
|
|
|
if ( ctx.hasQuotaManager()) {
|
|
|
|
// Check if the file content has been opened, we need the content to be opened to get the
|
|
// current file size
|
|
|
|
if ( file instanceof ContentNetworkFile) {
|
|
ContentNetworkFile contentFile = (ContentNetworkFile) file;
|
|
if ( contentFile.hasContent() == false)
|
|
{
|
|
contentFile.openContent( false, false);
|
|
}
|
|
}
|
|
else if( file instanceof TempNetworkFile)
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
throw new IOException("Invalid file class type, " + file.getClass().getName());
|
|
}
|
|
// Determine if the new file size will release space or require space allocating
|
|
|
|
if ( size > file.getFileSize())
|
|
{
|
|
|
|
// Calculate the space to be allocated
|
|
|
|
allocSize = size - file.getFileSize();
|
|
|
|
// Allocate space to extend the file
|
|
|
|
quotaMgr.allocateSpace(sess, tree, file, allocSize);
|
|
}
|
|
else
|
|
{
|
|
|
|
// Calculate the space to be released as the file is to be truncated, release the space if
|
|
// the file truncation is successful
|
|
releaseSize = file.getFileSize() - size;
|
|
}
|
|
}
|
|
|
|
// Check if this is a file extend, update the cached allocation size if necessary
|
|
|
|
if ( file instanceof ContentNetworkFile) {
|
|
|
|
// Get the cached state for the file
|
|
ContentNetworkFile contentFile = (ContentNetworkFile) file;
|
|
FileState fstate = contentFile.getFileState();
|
|
if ( fstate != null && size > fstate.getAllocationSize())
|
|
{
|
|
fstate.setAllocationSize(size);
|
|
}
|
|
}
|
|
|
|
if( file instanceof TempNetworkFile)
|
|
{
|
|
TempNetworkFile contentFile = (TempNetworkFile) file;
|
|
FileState fstate = contentFile.getFileState();
|
|
if ( fstate != null && size > fstate.getAllocationSize())
|
|
{
|
|
fstate.setAllocationSize(size);
|
|
}
|
|
}
|
|
|
|
// Set the file length
|
|
|
|
try
|
|
{
|
|
file.truncateFile(size);
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("unable to truncate the file + :" + file.getFullName(), ex);
|
|
}
|
|
// Check if we allocated space to the file
|
|
|
|
if ( allocSize > 0 && quotaMgr != null)
|
|
{
|
|
quotaMgr.releaseSpace(sess, tree, file.getFileId(), null, allocSize);
|
|
}
|
|
|
|
// Rethrow the exception
|
|
throw ex;
|
|
}
|
|
|
|
// Check if space has been released by the file resizing
|
|
|
|
if ( releaseSize > 0 && quotaMgr != null)
|
|
{
|
|
quotaMgr.releaseSpace(sess, tree, file.getFileId(), null, releaseSize);
|
|
}
|
|
// Debug
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Truncated file: network file=" + file + " size=" + size);
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read a block of data from the specified file.
|
|
*
|
|
* @param sess Session details
|
|
* @param tree Tree connection
|
|
* @param file Network file
|
|
* @param buf Buffer to return data to
|
|
* @param bufPos Starting position in the return buffer
|
|
* @param siz Maximum size of data to return
|
|
* @param filePos File offset to read data
|
|
* @return Number of bytes read
|
|
* @exception java.io.IOException The exception description.
|
|
*/
|
|
public int readFile(
|
|
SrvSession sess, TreeConnection tree, NetworkFile file,
|
|
byte[] buffer, int bufferPosition, int size, long fileOffset) throws IOException
|
|
{
|
|
// Check if the file is a directory
|
|
|
|
if(readLogger.isDebugEnabled())
|
|
{
|
|
readLogger.debug("read File:" + file + ", size" + size);
|
|
}
|
|
|
|
if(file.isDirectory())
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("read file called for a directory - throw AccessDeniedException");
|
|
}
|
|
throw new AccessDeniedException("read called for a directory");
|
|
}
|
|
|
|
// Read a block of data from the file
|
|
|
|
int count = file.readFile(buffer, size, bufferPosition, fileOffset);
|
|
|
|
if ( count == -1)
|
|
{
|
|
// Read count of -1 indicates a read past the end of file
|
|
|
|
count = 0;
|
|
}
|
|
|
|
// Debug
|
|
|
|
//ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
if (readLogger.isDebugEnabled())
|
|
{
|
|
readLogger.debug("Read bytes from file: network file=" + file + " buffer size=" + buffer.length + " buffer pos=" + bufferPosition +
|
|
" size=" + size + " file offset=" + fileOffset + " bytes read=" + count);
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* Seek to the specified file position.
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param file Network file.
|
|
* @param pos Position to seek to.
|
|
* @param typ Seek type.
|
|
* @return New file position, relative to the start of file.
|
|
*/
|
|
public long seekFile(SrvSession sess, TreeConnection tree, NetworkFile file, long pos, int typ) throws IOException
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("seek File");
|
|
}
|
|
|
|
// Check if the file is a directory
|
|
|
|
if ( file.isDirectory())
|
|
{
|
|
throw new AccessDeniedException();
|
|
}
|
|
|
|
// Set the file position
|
|
|
|
return file.seekFile(pos, typ);
|
|
}
|
|
|
|
/**
|
|
* Write a block of data to the file.
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection
|
|
* @param file Network file details
|
|
* @param buf byte[] Data to be written
|
|
* @param bufoff Offset within the buffer that the data starts
|
|
* @param siz int Data length
|
|
* @param fileoff Position within the file that the data is to be written.
|
|
* @return Number of bytes actually written
|
|
* @exception java.io.IOException The exception description.
|
|
*/
|
|
public int writeFile(SrvSession sess, TreeConnection tree, NetworkFile file,
|
|
byte[] buffer, int bufferOffset, int size, long fileOffset) throws IOException
|
|
{
|
|
if(writeLogger.isDebugEnabled())
|
|
{
|
|
writeLogger.debug("write File:" + file + " size:" + size);
|
|
}
|
|
|
|
// Check if there is a quota manager
|
|
|
|
ContentContext ctx = (ContentContext) tree.getContext();
|
|
QuotaManager quotaMgr = ctx.getQuotaManager();
|
|
|
|
long curSize = file.getFileSize();
|
|
|
|
if ( quotaMgr != null)
|
|
{
|
|
|
|
// Check if the file requires extending
|
|
|
|
long extendSize = 0L;
|
|
long endOfWrite = fileOffset + size;
|
|
|
|
if ( endOfWrite > curSize)
|
|
{
|
|
// Calculate the amount the file must be extended
|
|
|
|
extendSize = endOfWrite - file.getFileSize();
|
|
|
|
// Allocate space for the file extend
|
|
if(writeLogger.isDebugEnabled())
|
|
{
|
|
writeLogger.debug("writeFile: allocate more space fileName:" + file.getName() + ", extendTo:"+ extendSize);
|
|
}
|
|
|
|
|
|
long alloc = quotaMgr.allocateSpace(sess, tree, file, extendSize);
|
|
|
|
if(file instanceof TempNetworkFile)
|
|
{
|
|
TempNetworkFile tnf = (TempNetworkFile)file;
|
|
FileState fstate = tnf.getFileState();
|
|
if(fstate != null)
|
|
{
|
|
fstate.setAllocationSize(alloc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Write to the file
|
|
|
|
file.writeFile(buffer, size, bufferOffset, fileOffset);
|
|
|
|
// Check if the file size was reduced by the write, may have been extended previously
|
|
|
|
if ( quotaMgr != null)
|
|
{
|
|
|
|
// Check if the file size reduced
|
|
|
|
if ( file.getFileSize() < curSize)
|
|
{
|
|
|
|
// Release space that was freed by the write
|
|
|
|
quotaMgr.releaseSpace( sess, tree, file.getFileId(), file.getFullName(), curSize - file.getFileSize());
|
|
}
|
|
}
|
|
|
|
// Debug
|
|
|
|
if (writeLogger.isDebugEnabled())
|
|
{
|
|
writeLogger.debug("Wrote bytes to file: network file=" + file + " buffer size=" + buffer.length + " size=" + size + " file offset=" + fileOffset);
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Get the node for the specified path
|
|
*
|
|
* @param tree TreeConnection
|
|
* @param path String
|
|
* @return NodeRef
|
|
* @exception FileNotFoundException
|
|
*/
|
|
private NodeRef getNodeForPath(TreeConnection tree, String path)
|
|
throws FileNotFoundException
|
|
{
|
|
ContentContext ctx = (ContentContext) tree.getContext();
|
|
return getCifsHelper().getNodeRef(ctx.getRootNode(), path);
|
|
}
|
|
|
|
/**
|
|
* Get the node for the specified path
|
|
*
|
|
* @param tree TreeConnection
|
|
* @param path String
|
|
* @return NodeRef
|
|
* @exception FileNotFoundException
|
|
*/
|
|
public NodeRef getNodeForPath(NodeRef rootNode, String path)
|
|
throws FileNotFoundException
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("getNodeRefForPath:" + path);
|
|
}
|
|
|
|
return getCifsHelper().getNodeRef(rootNode, path);
|
|
}
|
|
|
|
/**
|
|
* Convert a node into a share relative path
|
|
*
|
|
* @param tree TreeConnection
|
|
* @param nodeRef NodeRef
|
|
* @return String
|
|
* @exception FileNotFoundException
|
|
*/
|
|
// private String getPathForNode( TreeConnection tree, NodeRef nodeRef)
|
|
// throws FileNotFoundException
|
|
// {
|
|
// // Convert the target node to a path
|
|
// ContentContext ctx = (ContentContext) tree.getContext();
|
|
//
|
|
// return getPathForNode(ctx.getRootNode(), nodeRef);
|
|
//
|
|
// }
|
|
//
|
|
/**
|
|
* Convert a node into a share relative path
|
|
*
|
|
* @param tree rootNode
|
|
* @param nodeRef NodeRef
|
|
* @return String
|
|
* @exception FileNotFoundException
|
|
*/
|
|
private String getPathForNode( NodeRef rootNode, NodeRef nodeRef)
|
|
throws FileNotFoundException
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("getPathForNode:" + nodeRef);
|
|
}
|
|
|
|
List<org.alfresco.service.cmr.model.FileInfo> linkPaths = null;
|
|
|
|
try
|
|
{
|
|
linkPaths = fileFolderService.getNamePath( rootNode, nodeRef);
|
|
}
|
|
catch ( org.alfresco.service.cmr.model.FileNotFoundException ex)
|
|
{
|
|
throw new FileNotFoundException();
|
|
}
|
|
|
|
// Build the share relative path to the node
|
|
|
|
StringBuilder pathStr = new StringBuilder();
|
|
|
|
for ( org.alfresco.service.cmr.model.FileInfo fInfo : linkPaths)
|
|
{
|
|
pathStr.append( FileName.DOS_SEPERATOR);
|
|
pathStr.append( fInfo.getName());
|
|
}
|
|
|
|
// Return the share relative path
|
|
|
|
return pathStr.toString();
|
|
}
|
|
|
|
/**
|
|
* Return the lock manager used by this filesystem
|
|
*
|
|
* @param sess SrvSession
|
|
* @param tree TreeConnection
|
|
* @return LockManager
|
|
*/
|
|
public LockManager getLockManager(SrvSession sess, TreeConnection tree)
|
|
{
|
|
AlfrescoContext alfCtx = (AlfrescoContext) tree.getContext();
|
|
return alfCtx.getLockManager();
|
|
}
|
|
|
|
/**
|
|
* Disk Size Interface implementation
|
|
*/
|
|
private interface DiskSizeInterfaceConsts
|
|
{
|
|
static final int DiskBlockSize = 512; // bytes per block
|
|
static final long DiskAllocationUnit = 32 * MemorySize.KILOBYTE;
|
|
static final long DiskBlocksPerUnit = DiskAllocationUnit / DiskBlockSize;
|
|
|
|
// Disk size returned in the content store does not support free/total size
|
|
|
|
static final long DiskSizeDefault = 1 * MemorySize.TERABYTE;
|
|
static final long DiskFreeDefault = DiskSizeDefault / 2;
|
|
}
|
|
|
|
/**
|
|
* Get the disk information for this shared disk device.
|
|
*
|
|
* @param ctx DiskDeviceContext
|
|
* @param diskDev SrvDiskInfo
|
|
* @exception IOException
|
|
*/
|
|
public void getDiskInformation(DiskDeviceContext ctx, SrvDiskInfo diskDev) throws IOException
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("getDiskInformation");
|
|
}
|
|
|
|
// Set the block size and blocks per allocation unit
|
|
diskDev.setBlockSize( DiskSizeInterfaceConsts.DiskBlockSize);
|
|
diskDev.setBlocksPerAllocationUnit( DiskSizeInterfaceConsts.DiskBlocksPerUnit);
|
|
|
|
// Get the free and total disk size in bytes from the content store
|
|
|
|
long freeSpace = contentService.getStoreFreeSpace();
|
|
long totalSpace= contentService.getStoreTotalSpace();
|
|
|
|
if ( totalSpace == -1L) {
|
|
|
|
// Use a fixed value for the total space, content store does not support size information
|
|
|
|
totalSpace = DiskSizeInterfaceConsts.DiskSizeDefault;
|
|
freeSpace = DiskSizeInterfaceConsts.DiskFreeDefault;
|
|
}
|
|
|
|
// Convert the total/free space values to allocation units
|
|
|
|
diskDev.setTotalUnits( totalSpace / DiskSizeInterfaceConsts.DiskAllocationUnit);
|
|
diskDev.setFreeUnits( freeSpace / DiskSizeInterfaceConsts.DiskAllocationUnit);
|
|
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("getDiskInformation returning diskDev:" + diskDev);
|
|
}
|
|
}
|
|
|
|
public void setCifsHelper(CifsHelper cifsHelper)
|
|
{
|
|
this.cifsHelper = cifsHelper;
|
|
}
|
|
|
|
@Override
|
|
public void treeOpened(SrvSession sess, TreeConnection tree)
|
|
{
|
|
// Nothing to do
|
|
}
|
|
|
|
@Override
|
|
public void treeClosed(SrvSession sess, TreeConnection tree)
|
|
{
|
|
// Nothing to do
|
|
}
|
|
|
|
// Implementation of IOCtlInterface
|
|
|
|
/**
|
|
* Process a filesystem I/O control request
|
|
*
|
|
* @param sess Server session
|
|
* @param tree Tree connection.
|
|
* @param ctrlCode I/O control code
|
|
* @param fid File id
|
|
* @param dataBuf I/O control specific input data
|
|
* @param isFSCtrl true if this is a filesystem control, or false for a device control
|
|
* @param filter if bit0 is set indicates that the control applies to the share root handle
|
|
* @return DataBuffer
|
|
* @exception IOControlNotImplementedException
|
|
* @exception SMBException
|
|
*/
|
|
public org.alfresco.jlan.util.DataBuffer processIOControl(SrvSession sess, TreeConnection tree, int ctrlCode, int fid, DataBuffer dataBuf,
|
|
boolean isFSCtrl, int filter)
|
|
throws IOControlNotImplementedException, SMBException
|
|
{
|
|
// Validate the file id
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("processIOControl ctrlCode: 0x" + Integer.toHexString(ctrlCode) + ", fid:" + fid);
|
|
}
|
|
|
|
final ContentContext ctx = (ContentContext) tree.getContext();
|
|
try
|
|
{
|
|
org.alfresco.jlan.util.DataBuffer buff = ioControlHandler.processIOControl(sess, tree, ctrlCode, fid, dataBuf, isFSCtrl, filter, this, ctx);
|
|
|
|
return buff;
|
|
}
|
|
catch(SMBException smbException)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("SMB Exception fid:" + fid, smbException);
|
|
}
|
|
throw smbException;
|
|
}
|
|
catch(IOControlNotImplementedException ioException)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("IO Control Not Implemented Exception fid:" + fid, ioException);
|
|
}
|
|
throw ioException;
|
|
}
|
|
}
|
|
|
|
|
|
public void setCheckOutCheckInService(CheckOutCheckInService service)
|
|
{
|
|
this.checkOutCheckInService = service;
|
|
}
|
|
|
|
/**
|
|
* @return the service to provide check-in and check-out data
|
|
*/
|
|
public final CheckOutCheckInService getCheckOutCheckInService()
|
|
{
|
|
return checkOutCheckInService;
|
|
}
|
|
|
|
// Implementation of RepositoryDiskInterface
|
|
@Override
|
|
public void copyContent(NodeRef rootNode, String fromPath, String toPath) throws FileNotFoundException
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("copyContent from:" + fromPath + " to:" + toPath);
|
|
}
|
|
|
|
NodeRef sourceNodeRef = getNodeForPath(rootNode, fromPath);
|
|
NodeRef targetNodeRef = getNodeForPath(rootNode, toPath);
|
|
|
|
Serializable prop = nodeService.getProperty(sourceNodeRef, ContentModel.PROP_CONTENT);
|
|
if(prop != null)
|
|
{
|
|
if(prop instanceof ContentData)
|
|
{
|
|
ContentData data = (ContentData)prop;
|
|
if(data.getMimetype().equalsIgnoreCase(MimetypeMap.MIMETYPE_BINARY))
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("mimetype is binary - guess mimetype has failed");
|
|
}
|
|
Serializable targetProp = nodeService.getProperty(targetNodeRef, ContentModel.PROP_CONTENT);
|
|
|
|
if(targetProp != null && targetProp instanceof ContentData)
|
|
{
|
|
ContentData targetData = (ContentData)targetProp;
|
|
logger.debug("copy the existing mimetype");
|
|
prop = ContentData.setMimetype(data, targetData.getMimetype());
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
nodeService.setProperty(targetNodeRef, ContentModel.PROP_CONTENT, prop);
|
|
}
|
|
else
|
|
{
|
|
// No content to set
|
|
logger.debug("no content to save");
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public NetworkFile createFile(NodeRef rootNode, String path, long allocationSize)
|
|
throws IOException
|
|
{
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("createFile :" + path);
|
|
}
|
|
|
|
try
|
|
{
|
|
NodeRef dirNodeRef;
|
|
String folderName;
|
|
|
|
String[] paths = FileName.splitPath(path);
|
|
|
|
if (paths[0] != null && paths[0].length() > 1)
|
|
{
|
|
// lookup parent directory
|
|
dirNodeRef = getNodeForPath(rootNode, paths[0]);
|
|
folderName = paths[1];
|
|
}
|
|
else
|
|
{
|
|
dirNodeRef = rootNode;
|
|
folderName = path;
|
|
}
|
|
|
|
NodeRef nodeRef = cifsHelper.createNode(dirNodeRef, folderName, ContentModel.TYPE_CONTENT);
|
|
|
|
nodeService.addAspect(nodeRef, ContentModel.ASPECT_NO_CONTENT, null);
|
|
|
|
File file = TempFileProvider.createTempFile("cifs", ".bin");
|
|
|
|
TempNetworkFile netFile = new TempNetworkFile(file, path);
|
|
netFile.setChanged(true);
|
|
|
|
// Always allow write access to a newly created file
|
|
netFile.setGrantedAccess(NetworkFile.READWRITE);
|
|
netFile.setAllowedAccess(NetworkFile.READWRITE);
|
|
|
|
|
|
|
|
// Generate a file id for the file
|
|
|
|
if ( netFile != null)
|
|
{
|
|
long id = DefaultTypeConverter.INSTANCE.convert(Long.class, nodeService.getProperty(nodeRef, ContentModel.PROP_NODE_DBID));
|
|
netFile.setFileId((int) (id & 0xFFFFFFFFL));
|
|
}
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Created file: path=" + path + " node=" + nodeRef + " network file=" + netFile);
|
|
}
|
|
|
|
// Return the new network file
|
|
|
|
return netFile;
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Create file - access denied, " + path);
|
|
}
|
|
|
|
// Convert to a filesystem access denied status
|
|
|
|
throw new AccessDeniedException("Unable to create file " + path);
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Create file - content I/O error, " + path);
|
|
}
|
|
|
|
throw ex;
|
|
}
|
|
catch (ContentIOException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Create file - content I/O error, " + path);
|
|
}
|
|
// Convert to a filesystem disk full status
|
|
|
|
throw new DiskFullException("Unable to create file " + path);
|
|
}
|
|
catch (AlfrescoRuntimeException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Create file error", ex);
|
|
}
|
|
|
|
// Convert to a general I/O exception
|
|
|
|
throw new IOException("Unable to create file " + path, ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Open the file - Repo Specific implementation
|
|
*/
|
|
public NetworkFile openFile(SrvSession session, TreeConnection tree, NodeRef rootNode, String path, OpenFileMode mode, boolean truncate) throws IOException
|
|
{
|
|
ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("openFile :" + path + ", mode:" + mode );
|
|
}
|
|
try
|
|
{
|
|
String name = path;
|
|
|
|
if(session.isPseudoFilesEnabled() && ctx.isPseudoFilesEnabled())
|
|
{
|
|
String[] paths = FileName.splitPath(name);
|
|
// lookup parent directory
|
|
NodeRef dirNodeRef = getNodeForPath(rootNode, paths[0]);
|
|
|
|
// Check whether we are opening a pseudo file
|
|
if(ctx.getPseudoFileOverlay().isPseudoFile(dirNodeRef, paths[1]))
|
|
{
|
|
PseudoFile pfile = ctx.getPseudoFileOverlay().getPseudoFile(dirNodeRef, paths[1]);
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Opened pseudo file :" + pfile);
|
|
}
|
|
return pfile.getFile( path);
|
|
}
|
|
}
|
|
|
|
// not a psudo file
|
|
|
|
NodeRef nodeRef = getNodeForPath(rootNode, path);
|
|
|
|
boolean readOnly=false;
|
|
|
|
// Check permissions on the file/folder
|
|
switch(mode)
|
|
{
|
|
case READ_ONLY:
|
|
// follow through
|
|
case ATTRIBUTES_ONLY:
|
|
if(permissionService.hasPermission(nodeRef, PermissionService.READ) == AccessStatus.DENIED)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("about to throw an no read access denied exception path:" +path);
|
|
}
|
|
throw new AccessDeniedException("No read access to " + path);
|
|
}
|
|
readOnly = true;
|
|
break;
|
|
|
|
case READ_WRITE:
|
|
case WRITE_ONLY:
|
|
if(permissionService.hasPermission(nodeRef, PermissionService.WRITE) == AccessStatus.DENIED)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("about to throw an no write access denied exception path:" + path);
|
|
}
|
|
|
|
throw new AccessDeniedException("No write access to " + path);
|
|
}
|
|
lockService.checkForLock(nodeRef);
|
|
readOnly=false;
|
|
break;
|
|
case DELETE:
|
|
lockService.checkForLock(nodeRef);
|
|
|
|
}
|
|
|
|
// Check if the node is a link node
|
|
NodeRef linkRef = (NodeRef) nodeService.getProperty(nodeRef, ContentModel.PROP_LINK_DESTINATION);
|
|
NetworkFile netFile = null;
|
|
|
|
if ( linkRef == null)
|
|
{
|
|
// A normal node, not a link node
|
|
|
|
// TODO MER REWRITE HERE
|
|
FileInfo fileInfo = cifsHelper.getFileInformation(nodeRef, "", false, false);
|
|
|
|
// TODO this is wasteful - the isDirectory is in the params. We should split off an openDirectory method.
|
|
if(fileInfo.isDirectory())
|
|
{
|
|
logger.debug("open file - is a directory!");
|
|
netFile = new AlfrescoFolder(path, fileInfo, readOnly);
|
|
}
|
|
else
|
|
{
|
|
// A normal file
|
|
switch (mode)
|
|
{
|
|
case READ_ONLY:
|
|
|
|
logger.debug("open file for read only");
|
|
netFile = ContentNetworkFile.createFile(nodeService, contentService, mimetypeService, getCifsHelper(), nodeRef, path, true, false, session);
|
|
netFile.setGrantedAccess( NetworkFile.READONLY);
|
|
break;
|
|
|
|
case READ_WRITE:
|
|
{
|
|
logger.debug("open file for read write");
|
|
File file = TempFileProvider.createTempFile("cifs", ".bin");
|
|
|
|
if(!truncate)
|
|
{
|
|
// Need to open a temp file with a copy of the content.
|
|
ContentReader reader = contentService.getReader(nodeRef, ContentModel.PROP_CONTENT);
|
|
if(reader != null)
|
|
{
|
|
reader.getContent(file);
|
|
}
|
|
}
|
|
|
|
netFile = new TempNetworkFile(file, name);
|
|
|
|
netFile.setGrantedAccess( NetworkFile.READWRITE);
|
|
|
|
if(truncate)
|
|
{
|
|
netFile.truncateFile(0);
|
|
}
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Created file: path=" + name + " node=" + nodeRef + " network file=" + netFile);
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case ATTRIBUTES_ONLY:
|
|
logger.debug("open file for attributes only");
|
|
netFile = ContentNetworkFile.createFile(nodeService, contentService, mimetypeService, getCifsHelper(), nodeRef, path, true, true, session);
|
|
netFile.setGrantedAccess( NetworkFile.READONLY);
|
|
break;
|
|
|
|
case DELETE:
|
|
//TODO Not sure about this one.
|
|
logger.debug("open file for delete");
|
|
netFile = ContentNetworkFile.createFile(nodeService, contentService, mimetypeService, getCifsHelper(), nodeRef, path, true, false, session);
|
|
netFile.setGrantedAccess( NetworkFile.READONLY);
|
|
break;
|
|
|
|
case WRITE_ONLY:
|
|
{
|
|
// consider this as open read/write/truncate)
|
|
logger.debug("open file write only");
|
|
File file = TempFileProvider.createTempFile("cifs", ".bin");
|
|
|
|
netFile = new TempNetworkFile(file, name);
|
|
|
|
// Needs to be READWRITE for JavaNetworkFile - there's no such thing as WRITEONLY!
|
|
netFile.setGrantedAccess( NetworkFile.READWRITE);
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Created temporary file: path=" + name + " node=" + nodeRef + " network file=" + netFile);
|
|
}
|
|
}
|
|
}
|
|
} // end of a normal file
|
|
}
|
|
else
|
|
{
|
|
// This is a link node
|
|
|
|
// TODO - This server name stuff should be replaced In particular the
|
|
// See PseudoFileOverlayImp
|
|
// Get the CIFS server name
|
|
|
|
String srvName = null;
|
|
SMBServer cifsServer = (SMBServer) session.getServer().getConfiguration().findServer( "CIFS");
|
|
|
|
if ( cifsServer != null)
|
|
{
|
|
// Use the CIFS server name in the URL
|
|
|
|
srvName = cifsServer.getServerName();
|
|
}
|
|
else
|
|
{
|
|
// Use the local server name in the URL
|
|
srvName = InetAddress.getLocalHost().getHostName();
|
|
}
|
|
|
|
// Convert the target node to a path, convert to URL format
|
|
|
|
String pathl = getPathForNode( rootNode, linkRef);
|
|
path = pathl.replace( FileName.DOS_SEPERATOR, '/');
|
|
|
|
// Build the URL file data
|
|
|
|
StringBuilder urlStr = new StringBuilder();
|
|
|
|
urlStr.append("[InternetShortcut]\r\n");
|
|
urlStr.append("URL=file://");
|
|
urlStr.append( srvName);
|
|
urlStr.append("/");
|
|
urlStr.append( tree.getSharedDevice().getName());
|
|
urlStr.append( path);
|
|
urlStr.append("\r\n");
|
|
|
|
// Create the in memory pseudo file for the URL link
|
|
|
|
byte[] urlData = urlStr.toString().getBytes();
|
|
|
|
// Get the file information for the link node
|
|
|
|
FileInfo fInfo = getCifsHelper().getFileInformation( nodeRef, false, isLockedFilesAsOffline);
|
|
|
|
// Set the file size to the actual data length
|
|
|
|
fInfo.setFileSize( urlData.length);
|
|
|
|
// Create the network file using the in-memory file data
|
|
|
|
netFile = new LinkMemoryNetworkFile( fInfo.getFileName(), urlData, fInfo, nodeRef);
|
|
netFile.setFullName( path);
|
|
}
|
|
|
|
// Generate a file id for the file
|
|
|
|
if ( netFile != null)
|
|
{
|
|
long id = DefaultTypeConverter.INSTANCE.convert(Long.class, nodeService.getProperty(nodeRef, ContentModel.PROP_NODE_DBID));
|
|
netFile.setFileId(( int) ( id & 0xFFFFFFFFL));
|
|
}
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Opened network file: path=" + path + " network file=" + netFile);
|
|
}
|
|
|
|
// Return the network file
|
|
|
|
return netFile;
|
|
}
|
|
catch (NodeLockedException nle)
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Open file - node is locked, " + path);
|
|
}
|
|
throw new AccessDeniedException("File is locked, no write access to " + path);
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
// Debug
|
|
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Open file - access denied, " + path);
|
|
}
|
|
// Convert to a filesystem access denied status
|
|
|
|
throw new AccessDeniedException("Open file " + path);
|
|
}
|
|
catch (AlfrescoRuntimeException ex)
|
|
{
|
|
// Debug
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Open file error", ex);
|
|
}
|
|
// Convert to a general I/O exception
|
|
|
|
throw new IOException("Open file " + path, ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Close the file.
|
|
*
|
|
* @exception java.io.IOException If an error occurs.
|
|
*/
|
|
public void closeFile(NodeRef rootNode, String path, NetworkFile file) throws IOException
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Close file:" + path + ", readOnly=" + file.isReadOnly() );
|
|
}
|
|
|
|
if( file instanceof PseudoNetworkFile)
|
|
{
|
|
file.close();
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Delete on close attribute - node needs to be deleted.
|
|
*/
|
|
if(file.hasDeleteOnClose())
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("closeFile has delete on close set path:" + path);
|
|
}
|
|
try
|
|
{
|
|
NodeRef target = getCifsHelper().getNodeRef(rootNode, path);
|
|
if(target!=null)
|
|
{
|
|
nodeService.deleteNode(target);
|
|
}
|
|
}
|
|
catch (org.alfresco.repo.security.permissions.AccessDeniedException ex)
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Delete file from close file- access denied", ex);
|
|
}
|
|
// Convert to a filesystem access denied status
|
|
throw new AccessDeniedException("Unable to delete " + path);
|
|
}
|
|
|
|
// Still need to close the open file handle.
|
|
file.close();
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Closed file: network file=" + file + " delete on close=" + file.hasDeleteOnClose());
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Check for a temp file - which will be a new file or a read/write file
|
|
if ( file instanceof TempNetworkFile)
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Got a temp network file to close path:" + path);
|
|
}
|
|
|
|
// Some content was written to the temp file.
|
|
TempNetworkFile tempFile =(TempNetworkFile)file;
|
|
|
|
NodeRef target = getCifsHelper().getNodeRef(rootNode, tempFile.getFullName());
|
|
|
|
if(nodeService.hasAspect(target, ContentModel.ASPECT_NO_CONTENT))
|
|
{
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("removed no content aspect");
|
|
}
|
|
nodeService.removeAspect(target, ContentModel.ASPECT_NO_CONTENT);
|
|
}
|
|
|
|
if(tempFile.isChanged())
|
|
{
|
|
tempFile.flushFile();
|
|
tempFile.close();
|
|
|
|
/*
|
|
* Need to work out whether content has changed. Some odd situations do not change content.
|
|
*/
|
|
boolean contentChanged = true;
|
|
|
|
ContentReader existingContent = contentService.getReader(target, ContentModel.PROP_CONTENT);
|
|
if(existingContent != null)
|
|
{
|
|
existingContent.getSize();
|
|
existingContent.getMimetype();
|
|
contentChanged = isContentChanged(existingContent, tempFile);
|
|
}
|
|
|
|
if(contentChanged)
|
|
{
|
|
logger.debug("content has changed, need to create a new content item");
|
|
|
|
/**
|
|
* Take over the behaviour of the auditable aspect
|
|
*/
|
|
getPolicyFilter().disableBehaviour(target, ContentModel.ASPECT_AUDITABLE);
|
|
nodeService.setProperty(target, ContentModel.PROP_MODIFIER, authService.getCurrentUserName());
|
|
nodeService.setProperty(target, ContentModel.PROP_MODIFIED, new Date(tempFile.getModifyDate()));
|
|
|
|
// Take an initial guess at the mimetype (if it has not been set by something already)
|
|
String mimetype = mimetypeService.guessMimetype(tempFile.getFullName(), new FileContentReader(tempFile.getFile()));
|
|
logger.debug("guesssed mimetype:" + mimetype);
|
|
|
|
String encoding;
|
|
// Take a guess at the locale
|
|
InputStream is = new BufferedInputStream(new FileInputStream(tempFile.getFile()));
|
|
try
|
|
{
|
|
ContentCharsetFinder charsetFinder = mimetypeService.getContentCharsetFinder();
|
|
Charset charset = charsetFinder.getCharset(is, mimetype);
|
|
encoding = charset.name();
|
|
}
|
|
finally
|
|
{
|
|
if(is != null)
|
|
{
|
|
try
|
|
{
|
|
is.close();
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
// Ignore
|
|
}
|
|
}
|
|
}
|
|
ContentWriter writer = contentService.getWriter(target, ContentModel.PROP_CONTENT, true);
|
|
writer.setMimetype(mimetype);
|
|
writer.setEncoding(encoding);
|
|
writer.putContent(tempFile.getFile());
|
|
} // if content changed
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
// Defer to the network file to close the stream and remove the content
|
|
|
|
file.close();
|
|
|
|
// DEBUG
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Closed file: network file=" + file + " delete on close=" + file.hasDeleteOnClose() + ", write count" + file.getWriteCount());
|
|
|
|
if ( file.hasDeleteOnClose() == false && file instanceof ContentNetworkFile)
|
|
{
|
|
ContentNetworkFile cFile = (ContentNetworkFile) file;
|
|
logger.debug(" File " + file.getFullName() + ", version=" + nodeService.getProperty( cFile.getNodeRef(), ContentModel.PROP_VERSION_LABEL));
|
|
}
|
|
}
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Exception in closeFile - path:" + path, e);
|
|
}
|
|
throw new IOException("Unable to closeFile :" + path + e.toString(), e);
|
|
}
|
|
catch (Error e)
|
|
{
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Exception in closeFile - path:" + path, e);
|
|
}
|
|
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param session
|
|
* @param tree
|
|
* @param file
|
|
*/
|
|
public void reduceQuota(SrvSession session, TreeConnection tree, NetworkFile file)
|
|
{
|
|
if(file.hasDeleteOnClose())
|
|
{
|
|
final ContentContext ctx = (ContentContext) tree.getContext();
|
|
|
|
if(logger.isDebugEnabled())
|
|
{
|
|
logger.debug("closeFile has delete on close set");
|
|
}
|
|
|
|
if(file instanceof TempNetworkFile)
|
|
{
|
|
TempNetworkFile tnf = (TempNetworkFile)file;
|
|
final QuotaManager quotaMgr = ctx.getQuotaManager();
|
|
if (quotaMgr != null)
|
|
{
|
|
try
|
|
{
|
|
quotaMgr.releaseSpace(session, tree, file.getFileId(), file.getName(), tnf.getFileSizeInt());
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
logger.error(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void deleteEmptyFile(NodeRef rootNode, String path)
|
|
{
|
|
try
|
|
{
|
|
NodeRef target = getCifsHelper().getNodeRef(rootNode, path);
|
|
if(target!=null)
|
|
{
|
|
if (nodeService.hasAspect(target, ContentModel.ASPECT_NO_CONTENT))
|
|
{
|
|
nodeService.deleteNode(target);
|
|
}
|
|
}
|
|
}
|
|
catch(IOException ne)
|
|
{
|
|
// Do nothing
|
|
if ( logger.isDebugEnabled())
|
|
{
|
|
logger.debug("Unable to delete empty file:" + path, ne);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public OpLockManager getOpLockManager(SrvSession sess, TreeConnection tree)
|
|
{
|
|
AlfrescoContext alfCtx = (AlfrescoContext) tree.getContext();
|
|
return alfCtx.getOpLockManager();
|
|
}
|
|
|
|
@Override
|
|
public boolean isOpLocksEnabled(SrvSession sess, TreeConnection tree)
|
|
{
|
|
if(getOpLockManager(sess, tree) != null)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Compare the content for significant changes. For example Project and Excel play with headers,
|
|
* which should not result in new versions being created.
|
|
* @param existingContent
|
|
* @param newFile
|
|
* @return true the content has changed, false the content has not changed significantly.
|
|
*/
|
|
private boolean isContentChanged(ContentReader existingContent, TempNetworkFile newFile)
|
|
{
|
|
return !contentComparator.isContentEqual(existingContent, newFile.getFile());
|
|
}
|
|
|
|
public void setContentComparator(ContentComparator contentComparator)
|
|
{
|
|
this.contentComparator = contentComparator;
|
|
}
|
|
|
|
public ContentComparator getContentComparator()
|
|
{
|
|
return contentComparator;
|
|
}
|
|
}
|