mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-06-02 17:35:18 +00:00
b8ff632f15
introduce a synthetic primary key into the stores table. git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@4492 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
949 lines
28 KiB
Java
949 lines
28 KiB
Java
/**
|
|
*
|
|
*/
|
|
package org.alfresco.repo.avm;
|
|
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.SortedMap;
|
|
|
|
import org.alfresco.repo.domain.PropertyValue;
|
|
import org.alfresco.service.cmr.avm.AVMException;
|
|
import org.alfresco.service.cmr.avm.AVMNodeDescriptor;
|
|
import org.alfresco.service.cmr.avm.AVMService;
|
|
import org.alfresco.service.cmr.avm.AVMStoreDescriptor;
|
|
import org.alfresco.service.cmr.avm.LayeringDescriptor;
|
|
import org.alfresco.service.cmr.avm.VersionDescriptor;
|
|
import org.alfresco.service.cmr.security.AuthenticationService;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.util.GUID;
|
|
|
|
/**
|
|
* Implementation of AVMRemoteTransport for the server side. It's
|
|
* job is to validate the authentication ticket passed with each
|
|
* method call, and to manage remote InputStreams and OutputStreams.
|
|
* @author britt
|
|
*/
|
|
public class AVMRemoteTransportService implements AVMRemoteTransport, Runnable
|
|
{
|
|
/**
|
|
* The map of handles to open input streams.
|
|
*/
|
|
private Map<String, InputStream> fInputStreams;
|
|
|
|
/**
|
|
* The map of handles to last accesses for input streams.
|
|
*/
|
|
private Map<String, Long> fInputLastAccessTimes;
|
|
|
|
/**
|
|
* The map of handles to busy flags.
|
|
*/
|
|
private Map<String, Boolean> fInputBusy;
|
|
|
|
/**
|
|
* The map of handles to open output streams.
|
|
*/
|
|
private Map<String, OutputStream> fOutputStreams;
|
|
|
|
/**
|
|
* The map of handles to last accesses for output streams.
|
|
*/
|
|
private Map<String, Long> fOutputLastAccessTimes;
|
|
|
|
/**
|
|
* The map of handles to busy flags.
|
|
*/
|
|
private Map<String, Boolean> fOutputBusy;
|
|
|
|
/**
|
|
* The stale handle time. This is the maximum time a handle
|
|
* can stay idle in milliseconds.
|
|
*/
|
|
private long fIdleTimeout;
|
|
|
|
/**
|
|
* Reference to AVMService.
|
|
*/
|
|
private AVMService fAVMService;
|
|
|
|
/**
|
|
* Reference to the AuthenticationService.
|
|
*/
|
|
private AuthenticationService fAuthService;
|
|
|
|
/**
|
|
* The thread for this Runnable.
|
|
*/
|
|
private Thread fThread;
|
|
|
|
/**
|
|
* Flag for whether this Runnable is done.
|
|
*/
|
|
private boolean fDone;
|
|
|
|
/**
|
|
* Default constructor.
|
|
*/
|
|
public AVMRemoteTransportService()
|
|
{
|
|
fIdleTimeout = 30000;
|
|
fInputStreams = new HashMap<String, InputStream>();
|
|
fInputLastAccessTimes = new HashMap<String, Long>();
|
|
fInputBusy = new HashMap<String, Boolean>();
|
|
fOutputStreams = new HashMap<String, OutputStream>();
|
|
fOutputLastAccessTimes = new HashMap<String, Long>();
|
|
fOutputBusy = new HashMap<String, Boolean>();
|
|
}
|
|
|
|
// Setters for Spring.
|
|
|
|
/**
|
|
* Set the Idle Timeout value.
|
|
* @param timeout The value to set.
|
|
*/
|
|
public void setIdleTimeout(long timeout)
|
|
{
|
|
fIdleTimeout = timeout;
|
|
}
|
|
|
|
/**
|
|
* Set the AVMService.
|
|
* @param service The service to set.
|
|
*/
|
|
public void setAvmService(AVMService service)
|
|
{
|
|
fAVMService = service;
|
|
}
|
|
|
|
public void setAuthenticationService(AuthenticationService service)
|
|
{
|
|
fAuthService = service;
|
|
}
|
|
|
|
/**
|
|
* The init method. This fires up a thread to check
|
|
* for closable streams.
|
|
*/
|
|
public void init()
|
|
{
|
|
fThread = new Thread(this);
|
|
fDone = false;
|
|
fThread.start();
|
|
}
|
|
|
|
/**
|
|
* The body of this Runnable.
|
|
*/
|
|
public synchronized void run()
|
|
{
|
|
while (!fDone)
|
|
{
|
|
try
|
|
{
|
|
wait(fIdleTimeout);
|
|
}
|
|
catch (InterruptedException e)
|
|
{
|
|
// Do nothing.
|
|
}
|
|
long now = System.currentTimeMillis();
|
|
List<String> toClose = new ArrayList<String>();
|
|
for (String handle : fInputLastAccessTimes.keySet())
|
|
{
|
|
if (fInputBusy.get(handle))
|
|
{
|
|
continue;
|
|
}
|
|
if (now - fInputLastAccessTimes.get(handle) > fIdleTimeout)
|
|
{
|
|
toClose.add(handle);
|
|
}
|
|
}
|
|
for (String handle : toClose)
|
|
{
|
|
try
|
|
{
|
|
fInputStreams.get(handle).close();
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
// Do nothing.
|
|
}
|
|
fInputStreams.remove(handle);
|
|
fInputLastAccessTimes.remove(handle);
|
|
fInputBusy.remove(handle);
|
|
}
|
|
toClose.clear();
|
|
for (String handle : fOutputLastAccessTimes.keySet())
|
|
{
|
|
if (fOutputBusy.get(handle))
|
|
{
|
|
continue;
|
|
}
|
|
if (now - fOutputLastAccessTimes.get(handle) > fIdleTimeout)
|
|
{
|
|
toClose.add(handle);
|
|
}
|
|
}
|
|
for (String handle : toClose)
|
|
{
|
|
try
|
|
{
|
|
fOutputStreams.get(handle).close();
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
// Do nothing.
|
|
}
|
|
fOutputStreams.remove(handle);
|
|
fOutputLastAccessTimes.remove(handle);
|
|
fOutputBusy.remove(handle);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shutdown the Runnable cleanly.
|
|
*/
|
|
public void shutDown()
|
|
{
|
|
synchronized (this)
|
|
{
|
|
fDone = true;
|
|
notifyAll();
|
|
}
|
|
try
|
|
{
|
|
fThread.join();
|
|
}
|
|
catch (InterruptedException e)
|
|
{
|
|
// Do nothing.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get an input handle. A handle is an opaque reference
|
|
* to a server side input stream.
|
|
* @param version The version to look under.
|
|
* @param path The path to the file.
|
|
* @return A handle.
|
|
*/
|
|
public String getInputHandle(String ticket, int version, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
InputStream in = fAVMService.getFileInputStream(version, path);
|
|
String handle = GUID.generate();
|
|
synchronized (this)
|
|
{
|
|
fInputStreams.put(handle, in);
|
|
fInputLastAccessTimes.put(handle, System.currentTimeMillis());
|
|
fInputBusy.put(handle, false);
|
|
}
|
|
return handle;
|
|
}
|
|
|
|
/**
|
|
* Read a chunk of data from a handle.
|
|
* @param handle The opaque input stream handle.
|
|
* @param count The number of bytes to try to read.
|
|
* @return An array of bytes. 0 length at eof.
|
|
*/
|
|
public byte [] readInput(String ticket, String handle, int count)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
InputStream in = null;
|
|
synchronized (this)
|
|
{
|
|
in = fInputStreams.get(handle);
|
|
if (in == null)
|
|
{
|
|
throw new AVMException("Invalid Input Handle.");
|
|
}
|
|
fInputBusy.put(handle, true);
|
|
fInputLastAccessTimes.put(handle, System.currentTimeMillis());
|
|
}
|
|
byte [] buff = new byte[count];
|
|
try
|
|
{
|
|
int read = in.read(buff);
|
|
if (read == -1)
|
|
{
|
|
read = 0;
|
|
}
|
|
if (read != count)
|
|
{
|
|
byte [] newBuff = new byte[read];
|
|
for (int i = 0; i < read; i++)
|
|
{
|
|
newBuff[i] = buff[i];
|
|
}
|
|
return newBuff;
|
|
}
|
|
return buff;
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
throw new AVMException("I/O Error.");
|
|
}
|
|
finally
|
|
{
|
|
synchronized (this)
|
|
{
|
|
fInputBusy.put(handle, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Close an input stream. Server side input streams are
|
|
* timer limited, ie, they will be automatically closed
|
|
* after a given idle time. However, be nice, and close
|
|
* handles when you're done.
|
|
* @param handle The opaque handle to the server side stream.
|
|
*/
|
|
public synchronized void closeInputHandle(String ticket, String handle)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
InputStream in = fInputStreams.get(handle);
|
|
if (in != null)
|
|
{
|
|
try
|
|
{
|
|
in.close();
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
// Do nothing.
|
|
}
|
|
fInputStreams.remove(handle);
|
|
fInputLastAccessTimes.remove(handle);
|
|
fInputBusy.remove(handle);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get an opaque handle to a server side output stream.
|
|
* @param path The path to the existing file.
|
|
* @return An opaque handle.
|
|
*/
|
|
public String getOutputHandle(String ticket, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
OutputStream out = fAVMService.getFileOutputStream(path);
|
|
String handle = GUID.generate();
|
|
synchronized (this)
|
|
{
|
|
fOutputStreams.put(handle, out);
|
|
fOutputLastAccessTimes.put(handle, System.currentTimeMillis());
|
|
fOutputBusy.put(handle, false);
|
|
}
|
|
return handle;
|
|
}
|
|
|
|
/**
|
|
* Write <code>count</code> bytes from buffer <code>buff</code>
|
|
* starting at offset <code>offset</code> in <code>buff</code>
|
|
* @param handle The opaque handle to the server side output stream.
|
|
* @param buff The data buffer.
|
|
* @param offset The offset within the buffer.
|
|
* @param count The number of bytes to write.
|
|
*/
|
|
public void writeOutput(String ticket, String handle, byte [] buff, int count)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
OutputStream out = null;
|
|
synchronized (this)
|
|
{
|
|
out = fOutputStreams.get(handle);
|
|
if (out == null)
|
|
{
|
|
throw new AVMException("Invalid Output Handle.");
|
|
}
|
|
fOutputBusy.put(handle, true);
|
|
fOutputLastAccessTimes.put(handle, System.currentTimeMillis());
|
|
}
|
|
try
|
|
{
|
|
out.write(buff, 0, count);
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
throw new AVMException("I/O Errror.");
|
|
}
|
|
finally
|
|
{
|
|
synchronized (this)
|
|
{
|
|
fOutputBusy.put(handle, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Close the server side output stream designated by the handle.
|
|
* @param handle The handle to the server side output stream.
|
|
*/
|
|
public synchronized void closeOutputHandle(String ticket, String handle)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
OutputStream out = fOutputStreams.get(handle);
|
|
if (out != null)
|
|
{
|
|
try
|
|
{
|
|
out.close();
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
// Do nothing.
|
|
}
|
|
fOutputStreams.remove(handle);
|
|
fOutputLastAccessTimes.remove(handle);
|
|
fOutputBusy.remove(handle);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a listing of a directories direct contents.
|
|
* @param version The version to look under.
|
|
* @param path The path to the directory.
|
|
* @return A sorted listing.
|
|
*/
|
|
public SortedMap<String, AVMNodeDescriptor>
|
|
getDirectoryListingDirect(String ticket, int version, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getDirectoryListingDirect(version, path);
|
|
}
|
|
|
|
/**
|
|
* Get a listing of a directory.
|
|
* @param version The version to look under.
|
|
* @param path The path to the directory.
|
|
* @return A sorted listing.
|
|
*/
|
|
public SortedMap<String, AVMNodeDescriptor>
|
|
getDirectoryListing(String ticket, int version, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getDirectoryListing(version, path);
|
|
}
|
|
|
|
/**
|
|
* Get a directory listing from a node descriptor.
|
|
* @param dir The directory node descriptor.
|
|
* @return A sorted listing.
|
|
*/
|
|
public SortedMap<String, AVMNodeDescriptor>
|
|
getDirectoryListing(String ticket, AVMNodeDescriptor dir)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getDirectoryListing(dir);
|
|
}
|
|
|
|
/**
|
|
* Get the names of nodes that have been deleted in a directory.
|
|
* @param version The version to look under.
|
|
* @param path The path to the directory.
|
|
* @return A list of deleted names.
|
|
*/
|
|
public List<String> getDeleted(String ticket, int version, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getDeleted(version, path);
|
|
}
|
|
|
|
/**
|
|
* Create a file and return a handle to an output stream.
|
|
* @param path The path to the file.
|
|
* @param name The name of the file to create.
|
|
* @return An opaque handle to a server side output stream.
|
|
*/
|
|
public String createFile(String ticket, String path, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
OutputStream out = fAVMService.createFile(path, name);
|
|
String handle = GUID.generate();
|
|
synchronized (this)
|
|
{
|
|
fOutputStreams.put(handle, out);
|
|
fOutputLastAccessTimes.put(handle, System.currentTimeMillis());
|
|
fOutputBusy.put(handle, false);
|
|
}
|
|
return handle;
|
|
}
|
|
|
|
/**
|
|
* Create a directory.
|
|
* @param path The path to the containing directory.
|
|
* @param name The name for the new directory.
|
|
*/
|
|
public void createDirectory(String ticket, String path, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.createDirectory(path, name);
|
|
}
|
|
|
|
/**
|
|
* Create a new layered file.
|
|
* @param targetPath The path that is targeted.
|
|
* @param parent The path to the parent directory.
|
|
* @param name The name for the new file.
|
|
*/
|
|
public void createLayeredFile(String ticket, String targetPath, String parent, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.createLayeredFile(targetPath, parent, name);
|
|
}
|
|
|
|
/**
|
|
* Create a layered directory.
|
|
* @param targetPath The path that is targeted.
|
|
* @param parent The parent directory.
|
|
* @param name The name of the new directory.
|
|
*/
|
|
public void createLayeredDirectory(String ticket, String targetPath, String parent, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.createLayeredDirectory(targetPath, parent, name);
|
|
}
|
|
|
|
/**
|
|
* Set a layered directory node to point at a different target.
|
|
* @param path The path to the layered directory node.
|
|
* @param target The new target.
|
|
*/
|
|
public void retargetLayeredDirectory(String ticket, String path, String target)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.retargetLayeredDirectory(path, target);
|
|
}
|
|
|
|
/**
|
|
* Create a new AVMStore.
|
|
* @param name The name to give the new store.
|
|
*/
|
|
public void createAVMStore(String ticket, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.createAVMStore(name);
|
|
}
|
|
|
|
/**
|
|
* Create a new branch.
|
|
* @param version The version to look under for the source node.
|
|
* @param srcPath The path to the source node.
|
|
* @param dstPath The path to the destination directory.
|
|
* @param name The name of the new branch.
|
|
*/
|
|
public void createBranch(String ticket, int version, String srcPath, String dstPath, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.createBranch(version, srcPath, dstPath, name);
|
|
}
|
|
|
|
/**
|
|
* Remove a node.
|
|
* @param parent The path to the parent directory.
|
|
* @param name The name of the node to remove.
|
|
*/
|
|
public void removeNode(String ticket, String parent, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.removeNode(parent, name);
|
|
}
|
|
|
|
/**
|
|
* Rename a node.
|
|
* @param srcParent The source directory path.
|
|
* @param srcName The source node name.
|
|
* @param dstParent The destination directory path.
|
|
* @param dstName The destination name for the node.
|
|
*/
|
|
public void rename(String ticket, String srcParent, String srcName, String dstParent, String dstName)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.rename(srcParent, srcName, dstParent, dstName);
|
|
}
|
|
|
|
/**
|
|
* Uncover a name in a layered directory.
|
|
* @param dirPath The path to the directory.
|
|
* @param name The name to uncover.
|
|
*/
|
|
public void uncover(String ticket, String dirPath, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.uncover(dirPath, name);
|
|
}
|
|
|
|
/**
|
|
* Get the latest version id of the given AVMStore.
|
|
* @param storeName The name of the AVMStore.
|
|
* @return The latest version id.
|
|
*/
|
|
public int getLatestVersionID(String ticket, String storeName)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getNextVersionID(storeName);
|
|
}
|
|
|
|
/**
|
|
* Get the id of the latest version snapshot.
|
|
* @param storeName The store name.
|
|
* @return The id.
|
|
*/
|
|
public int getLatestSnapshotID(String ticket, String storeName)
|
|
{
|
|
return fAVMService.getLatestSnapshotID(storeName);
|
|
}
|
|
|
|
/**
|
|
* Snapshot an AVMStore.
|
|
* @param store The name of the AVMStore to snapshot.
|
|
* @return The version id of the new snapshot.
|
|
*/
|
|
public int createSnapshot(String ticket, String store)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.createSnapshot(store, null, null);
|
|
}
|
|
|
|
/**
|
|
* Get a List of all versions in a given store.
|
|
* @param name The name of the store.
|
|
* @return A List of VersionDescriptors.
|
|
*/
|
|
public List<VersionDescriptor> getAVMStoreVersions(String ticket, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getAVMStoreVersions(name);
|
|
}
|
|
|
|
/**
|
|
* Get AVMStore versions between given dates.
|
|
* @param name The name of the store.
|
|
* @param from The date from which (inclusive).
|
|
* @param to The date to which (inclusive).
|
|
* @return A List of VersionDescriptors.
|
|
*/
|
|
public List<VersionDescriptor> getAVMStoreVersions(String ticket, String name, Date from, Date to)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getAVMStoreVersions(name, from, to);
|
|
}
|
|
|
|
/**
|
|
* Get a list of all AVM stores.
|
|
* @return A List of AVMStoreDescriptors.
|
|
*/
|
|
public List<AVMStoreDescriptor> getAVMStores(String ticket)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getAVMStores();
|
|
}
|
|
|
|
/**
|
|
* Get the descriptor for a given AVMStore.
|
|
* @param name The name of the store.
|
|
* @return An AVMStoreDescriptor.
|
|
*/
|
|
public AVMStoreDescriptor getAVMStore(String ticket, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getAVMStore(name);
|
|
}
|
|
|
|
/**
|
|
* Get the specified root of the specified store.
|
|
* @param version The version number to fetch.
|
|
* @param name The name of the store.
|
|
* @return The AVMNodeDescriptor for the root.
|
|
*/
|
|
public AVMNodeDescriptor getAVMStoreRoot(String ticket, int version, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getAVMStoreRoot(version, name);
|
|
}
|
|
|
|
/**
|
|
* Get a descriptor for the specified node.
|
|
* @param version The version to look under.
|
|
* @param path The path to the node.
|
|
* @return An AVMNodeDescriptor.
|
|
*/
|
|
public AVMNodeDescriptor lookup(String ticket, int version, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.lookup(version, path);
|
|
}
|
|
|
|
/**
|
|
* Get a descriptor for the specified node.
|
|
* @param dir The descriptor for the directory node.
|
|
* @param name The name of the node to lookup.
|
|
* @return An AVMNodeDescriptor.
|
|
*/
|
|
public AVMNodeDescriptor lookup(String ticket, AVMNodeDescriptor dir, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.lookup(dir, name);
|
|
}
|
|
|
|
/**
|
|
* Get the indirection path for a node.
|
|
* @param version The version to look under.
|
|
* @param path The path to the node.
|
|
* @return The indirection path/target.
|
|
*/
|
|
public String getIndirectionPath(String ticket, int version, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getIndirectionPath(version, path);
|
|
}
|
|
|
|
/**
|
|
* Purge an AVMStore.
|
|
* @param name The name of the store to purge.
|
|
*/
|
|
public void purgeAVMStore(String ticket, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.purgeAVMStore(name);
|
|
}
|
|
|
|
/**
|
|
* Purge a given version from a given store.
|
|
* @param version The version id.
|
|
* @param name The name of the store.
|
|
*/
|
|
public void purgeVersion(String ticket, int version, String name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.purgeVersion(version, name);
|
|
}
|
|
|
|
/**
|
|
* Turn a directory into a primary indirection node.
|
|
* @param path The path to the directory.
|
|
*/
|
|
public void makePrimary(String ticket, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.makePrimary(path);
|
|
}
|
|
|
|
/**
|
|
* Get a list of ancestors of a node.
|
|
* @param desc The descriptor of the node whose history is to be fetched.
|
|
* @param count The maximum number of ancestors that will be returned.
|
|
* @return A List of descriptors for ancestors starting most recent first.
|
|
*/
|
|
public List<AVMNodeDescriptor> getHistory(String ticket, AVMNodeDescriptor desc, int count)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getHistory(desc, count);
|
|
}
|
|
|
|
/**
|
|
* Turn on or off a directory's opacity.
|
|
* @param path The path to the directory.
|
|
* @param opacity Whether the directory should be opaque or not.
|
|
*/
|
|
public void setOpacity(String ticket, String path, boolean opacity)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.setOpacity(path, opacity);
|
|
}
|
|
|
|
/**
|
|
* Get the most recent common ancestor of two nodes.
|
|
* @param left One node.
|
|
* @param right The other node.
|
|
* @return The common ancestor.
|
|
*/
|
|
public AVMNodeDescriptor getCommonAncestor(String ticket, AVMNodeDescriptor left, AVMNodeDescriptor right)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getCommonAncestor(left, right);
|
|
}
|
|
|
|
/**
|
|
* Get layering information about a path.
|
|
* @param version The version to look under.
|
|
* @param path The path to the node.
|
|
* @return A LayeringDescriptor.
|
|
*/
|
|
public LayeringDescriptor getLayeringInfo(String ticket, int version, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getLayeringInfo(version, path);
|
|
}
|
|
|
|
/**
|
|
* Set a property on a node.
|
|
* @param path The path to the node.
|
|
* @param name The name of the property.
|
|
* @param value The value to give the property.
|
|
*/
|
|
public void setNodeProperty(String ticket, String path, QName name, PropertyValue value)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.setNodeProperty(path, name, value);
|
|
}
|
|
|
|
/**
|
|
* Set a group of properties on a node.
|
|
* @param path The path to the node.
|
|
* @param properties A Map of QNames to PropertyValues to set.
|
|
*/
|
|
public void setNodeProperties(String ticket, String path, Map<QName, PropertyValue> properties)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.setNodeProperties(path, properties);
|
|
}
|
|
|
|
/**
|
|
* Get the value of a node property.
|
|
* @param version The version to look under.
|
|
* @param path The path to the node.
|
|
* @param name The name of the property.
|
|
* @return A PropertyValue.
|
|
*/
|
|
public PropertyValue getNodeProperty(String ticket, int version, String path, QName name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getNodeProperty(version, path, name);
|
|
}
|
|
|
|
/**
|
|
* Get all properties of a node.
|
|
* @param version The version.
|
|
* @param path The path to the node.
|
|
* @return A Map of QNames to PropertyValues.
|
|
*/
|
|
public Map<QName, PropertyValue> getNodeProperties(String ticket, int version, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getNodeProperties(version, path);
|
|
}
|
|
|
|
/**
|
|
* Delete a property from a node.
|
|
* @param path The path to the node.
|
|
* @param name The name of the property.
|
|
*/
|
|
public void deleteNodeProperty(String ticket, String path, QName name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.deleteNodeProperty(path, name);
|
|
}
|
|
|
|
/**
|
|
* Delete all properties from a node.
|
|
* @param path The path to the node.
|
|
*/
|
|
public void deleteNodeProperties(String ticket, String path)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.deleteNodeProperties(path);
|
|
}
|
|
|
|
/**
|
|
* Set a property on a store.
|
|
* @param store The name of the store.
|
|
* @param name The name of the property to set.
|
|
* @param value The value of the property to set.
|
|
*/
|
|
public void setStoreProperty(String ticket, String store, QName name, PropertyValue value)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.setStoreProperty(store, name, value);
|
|
}
|
|
|
|
/**
|
|
* Set a group of properties on a store.
|
|
* @param store The name of the store.
|
|
* @param props A Map of QNames to PropertyValues to set.
|
|
*/
|
|
public void setStoreProperties(String ticket, String store, Map<QName, PropertyValue> props)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.setStoreProperties(store, props);
|
|
}
|
|
|
|
/**
|
|
* Get a property from a store.
|
|
* @param store The name of the store.
|
|
* @param name The name of the property.
|
|
* @return A PropertyValue.
|
|
*/
|
|
public PropertyValue getStoreProperty(String ticket, String store, QName name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getStoreProperty(store, name);
|
|
}
|
|
|
|
/**
|
|
* Query a store for keys that match a pattern.
|
|
* @param store The store name.
|
|
* @param keyPattern The sql 'like' pattern.
|
|
* @return A Map of keys to values.
|
|
*/
|
|
public Map<QName, PropertyValue> queryStorePropertyKey(String ticket, String store, QName keyPattern)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.queryStorePropertyKey(store, keyPattern);
|
|
}
|
|
|
|
/**
|
|
* Query all stores for keys that match a pattern.
|
|
* @param keyPattern The sql 'like' pattern.
|
|
* @return A Map of store names to Maps of matching keys to values.
|
|
*/
|
|
public Map<String, Map<QName, PropertyValue>> queryStoresPropertyKey(String ticket, QName keyPattern)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.queryStoresPropertyKeys(keyPattern);
|
|
}
|
|
|
|
/**
|
|
* Get all the properties on a store.
|
|
* @param store The name of the store.
|
|
* @return A Map of QNames to PropertyValues.
|
|
*/
|
|
public Map<QName, PropertyValue> getStoreProperties(String ticket, String store)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
return fAVMService.getStoreProperties(store);
|
|
}
|
|
|
|
/**
|
|
* Delete a property from a store.
|
|
* @param store The name of the store.
|
|
* @param name The name of the property.
|
|
*/
|
|
public void deleteStoreProperty(String ticket, String store, QName name)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.deleteStoreProperty(store, name);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see org.alfresco.repo.avm.AVMRemoteTransport#renameStore(java.lang.String, java.lang.String, java.lang.String)
|
|
*/
|
|
public void renameStore(String ticket, String sourceName, String destName)
|
|
{
|
|
fAuthService.validate(ticket);
|
|
fAVMService.renameStore(sourceName, destName);
|
|
}
|
|
}
|