/*
* Copyright (C) 2005-2007 Alfresco Software Limited.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program 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 General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* As a special exception to the terms and conditions of version 2.0 of
* the GPL, you may redistribute this Program in connection with Free/Libre
* and Open Source Software ("FLOSS") applications as described in Alfresco's
* FLOSS exception. You should have recieved a copy of the text describing
* the FLOSS exception, and it is also available here:
* http://www.alfresco.com/legal/licensing" */
package org.alfresco.repo.avm;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
import org.alfresco.repo.avm.util.BulkLoader;
import org.alfresco.repo.domain.PropertyValue;
import org.alfresco.service.cmr.avm.AVMNodeDescriptor;
import org.alfresco.service.cmr.avm.AVMNotFoundException;
import org.alfresco.service.cmr.avm.AVMService;
import org.alfresco.service.cmr.avm.AVMStoreDescriptor;
import org.alfresco.service.cmr.avm.VersionDescriptor;
import org.alfresco.service.cmr.avm.locking.AVMLock;
import org.alfresco.service.cmr.avm.locking.AVMLockingService;
import org.alfresco.service.cmr.avmsync.AVMDifference;
import org.alfresco.service.cmr.avmsync.AVMSyncService;
import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.StoreRef;
import org.alfresco.service.cmr.security.PermissionService;
import org.alfresco.service.namespace.QName;
import org.springframework.context.support.FileSystemXmlApplicationContext;
/**
* An interactive console for the AVM repository.
*
* @author britt
* @author Gavin Cornwell
*/
public class AVMInterpreter
{
private static final Pattern collectionPattern = Pattern.compile("^\\[(.*)\\]$");
private static final Pattern nodeRefPattern = Pattern.compile("^\\w+://\\w+\\w+$");
private static final Pattern integerPattern = Pattern.compile("^\\d+$");
private static final Pattern dateTimePattern = Pattern.compile("^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$");
/**
* The service interface.
*/
private AVMService fService;
/**
* The sync service.
*/
private AVMSyncService fSyncService;
/**
* The locking service.
*/
private AVMLockingService fLockingService;
/**
* The permission service.
*/
private PermissionService fPermissionService;
/**
* The reader for interaction.
*/
private BufferedReader fIn;
/**
* The Bulk Loader.
*/
private BulkLoader fLoader;
/**
* Main entry point.
* Syntax: AVMInteractiveConsole storage (new|old).
*/
public static void main(String[] args)
{
FileSystemXmlApplicationContext context =
new FileSystemXmlApplicationContext("config/alfresco/application-context.xml");
AVMInterpreter console = new AVMInterpreter();
console.setAvmService((AVMService)context.getBean("AVMService"));
console.setAvmSyncService((AVMSyncService)context.getBean("AVMSyncService"));
console.setAvmLockingService((AVMLockingService)context.getBean("AVMLockingService"));
console.setPermissionService((PermissionService)context.getBean("PermissionService"));
BulkLoader loader = new BulkLoader();
loader.setAvmService((AVMService)context.getBean("AVMService"));
console.setBulkLoader(loader);
console.rep();
context.close();
}
/**
* Make up a new console.
*/
public AVMInterpreter()
{
fIn = new BufferedReader(new InputStreamReader(System.in));
}
/**
* Set the AVMService.
* @param service The AVMService instance.
*/
public void setAvmService(AVMService service)
{
fService = service;
}
/**
* Set the AVM sync service.
* @param syncService
*/
public void setAvmSyncService(AVMSyncService syncService)
{
fSyncService = syncService;
}
/**
* Set the AVM locking service.
* @param lockService
*/
public void setAvmLockingService(AVMLockingService lockService)
{
fLockingService = lockService;
}
/**
* Set the PermissionService.
* @param service The PermissionService instance.
*/
public void setPermissionService(PermissionService service)
{
fPermissionService = service;
}
/**
* Set the bulk loader.
* @param loader
*/
public void setBulkLoader(BulkLoader loader)
{
fLoader = loader;
}
/**
* A Read-Eval-Print loop.
*/
public void rep()
{
while (true)
{
System.out.print("> ");
try
{
String line = fIn.readLine();
if (line.equals("exit"))
{
return;
}
System.out.println(interpretCommand(line, fIn));
}
catch (IOException ie)
{
ie.printStackTrace(System.err);
System.exit(2);
}
}
}
/**
* Interpret a single command using the BufferedReader passed in for any data needed.
* @param line The unparsed command
* @param in A Reader to be used for commands that need input data.
* @return The textual output of the command.
*/
public String interpretCommand(String line, BufferedReader in)
{
String[] command = line.split(",\\s+");
if (command.length == 0)
{
command = new String[1];
command[0] = line;
}
try
{
ByteArrayOutputStream bout = new ByteArrayOutputStream();
PrintStream out = new PrintStream(bout);
if (command[0].equals("ls"))
{
if (command.length < 2)
{
return "Syntax Error.";
}
int version = (command.length == 2) ? -1 : Integer.parseInt(command[2]);
AVMNodeDescriptor desc = fService.lookup(version, command[1]);
if (desc == null)
{
return "Not Found.";
}
Map<String, AVMNodeDescriptor> listing =
fService.getDirectoryListing(desc, true);
for (String name : listing.keySet())
{
out.println(name + " " + listing.get(name));
}
}
else if (command[0].equals("lsr"))
{
if (command.length < 2)
{
return "Syntax Error.";
}
int version = (command.length == 2) ? -1 : Integer.parseInt(command[2]);
AVMNodeDescriptor desc = fService.lookup(version, command[1]);
recursiveList(out, desc, 0);
}
else if (command[0].equals("lsrep"))
{
List<AVMStoreDescriptor> repos = fService.getStores();
for (AVMStoreDescriptor repo : repos)
{
out.println(repo);
}
}
else if (command[0].equals("lsver"))
{
if (command.length != 2)
{
return "Syntax Error.";
}
List<VersionDescriptor> listing = fService.getStoreVersions(command[1]);
for (VersionDescriptor desc : listing)
{
out.println(desc);
}
}
else if (command[0].equals("mkrep"))
{
if (command.length != 2)
{
return "Syntax Error.";
}
fService.createStore(command[1]);
}
else if (command[0].equals("load"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fLoader.recursiveLoad(command[1], command[2]);
}
else if (command[0].equals("mkdir"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fService.createDirectory(command[1], command[2]);
}
else if (command[0].equals("mkbr"))
{
if (command.length != 5)
{
return "Syntax Error.";
}
fService.createBranch(Integer.parseInt(command[4]), command[1], command[2], command[3]);
}
else if (command[0].equals("mkldir"))
{
if (command.length != 4)
{
return "Syntax Error.";
}
fService.createLayeredDirectory(command[1], command[2], command[3]);
}
else if (command[0].equals("rename"))
{
if (command.length != 5)
{
return "Syntax Error.";
}
fService.rename(command[1], command[2], command[3], command[4]);
}
else if (command[0].equals("cp"))
{
if (command.length != 5)
{
return "Syntax Error.";
}
InputStream fin = fService.getFileInputStream(Integer.parseInt(command[2]), command[1]);
OutputStream fout = fService.createFile(command[3], command[4]);
byte [] buff = new byte[8192];
int read;
while ((read = fin.read(buff)) != -1)
{
fout.write(buff, 0, read);
}
fin.close();
fout.close();
}
else if (command[0].equals("retarget"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fService.retargetLayeredDirectory(command[1], command[2]);
}
else if (command[0].equals("mkprimary"))
{
if (command.length != 2)
{
return "Syntax Error.";
}
fService.makePrimary(command[1]);
}
else if (command[0].equals("mklfile"))
{
if (command.length != 4)
{
return "Syntax Error.";
}
fService.createLayeredFile(command[1], command[2], command[3]);
}
else if (command[0].equals("snap"))
{
if (command.length != 2)
{
return "Syntax Error.";
}
fService.createSnapshot(command[1], null, null);
}
else if (command[0].equals("cat"))
{
if (command.length < 2)
{
return "Syntax Error.";
}
int version = (command.length == 2) ? -1 : Integer.parseInt(command[2]);
BufferedReader reader =
new BufferedReader(
new InputStreamReader(fService.getFileInputStream(version, command[1])));
String l;
while ((l = reader.readLine()) != null)
{
out.println(l);
}
reader.close();
}
else if (command[0].equals("rm"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fService.removeNode(command[1], command[2]);
}
else if (command[0].equals("rmrep"))
{
if (command.length != 2)
{
return "Syntax Error.";
}
fService.purgeStore(command[1]);
}
else if (command[0].equals("rmver"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fService.purgeVersion(Integer.parseInt(command[2]), command[1]);
}
else if (command[0].equals("write"))
{
if (command.length != 2)
{
return "Syntax Error.";
}
PrintStream ps =
new PrintStream(fService.getFileOutputStream(command[1]));
String l;
while (!(l = in.readLine()).equals(""))
{
ps.println(l);
}
ps.close();
}
else if (command[0].equals("create"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
PrintStream ps =
new PrintStream(fService.createFile(command[1], command[2]));
String l;
while (!(l = in.readLine()).equals(""))
{
ps.println(l);
}
ps.close();
}
else if (command[0].equals("stat"))
{
if (command.length < 2)
{
return "Syntax Error.";
}
int version = (command.length == 2) ? -1 : Integer.parseInt(command[2]);
AVMNodeDescriptor desc = fService.lookup(version, command[1]);
out.println(desc);
out.println("Version: " + desc.getVersionID());
out.println("Owner: " + desc.getOwner());
out.println("Mod Time: " + new Date(desc.getModDate()));
}
else if (command[0].equals("getnodeproperties"))
{
if (command.length < 2)
{
return "Syntax Error.";
}
int version = (command.length == 2) ? -1 : Integer.parseInt(command[2]);
final Map<QName, PropertyValue> properties = fService.getNodeProperties(version, command[1]);
for (final Map.Entry<QName, PropertyValue> p : properties.entrySet())
{
out.println(p.getKey() + ": " + p.getValue());
}
}
else if (command[0].equals("setnodepermission"))
{
if (command.length != 4)
{
return "Syntax Error.";
}
fPermissionService.setPermission(
AVMNodeConverter.ToNodeRef(-1, command[1]), command[2], command[3], true);
}
else if (command[0].equals("clearnodepermission"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fPermissionService.clearPermission(
AVMNodeConverter.ToNodeRef(-1, command[1]), command[2]);
}
else if (command[0].equals("descnode"))
{
if (command.length < 2)
{
return "Syntax Error.";
}
String path = command[1];
int version = (command.length == 2) ? -1 : Integer.parseInt(command[2]);
AVMNodeDescriptor nodeDesc = fService.lookup(version, path);
if (nodeDesc == null)
{
return "Path Not Found.";
}
out.println(nodeDesc.toString());
out.println("isDirectory: " + nodeDesc.isDirectory());
out.println("isFile: " + nodeDesc.isFile());
out.println("isPrimary: " + nodeDesc.isPrimary());
out.println("isOpaque: " + nodeDesc.getOpacity());
out.println("creator: " + nodeDesc.getCreator());
out.println("owner: " + nodeDesc.getOwner());
out.println("lastModifier: " + nodeDesc.getLastModifier());
out.println("created: " + new Date(nodeDesc.getCreateDate()));
out.println("modified: " + new Date(nodeDesc.getModDate()));
out.println("lastAccess: " + new Date(nodeDesc.getAccessDate()));
// get lock information
String lockPath = path.substring(path.indexOf("/"));
String store = path.substring(0, path.indexOf(":"));
String mainStore = store;
if (store.indexOf("--") != -1)
{
mainStore = store.substring(0, store.indexOf("--"));
}
try
{
AVMLock lock = fLockingService.getLock(mainStore, lockPath);
out.print("lock: ");
if (lock != null)
{
out.print("store = ");
out.print(lock.getStore());
out.print(", owners = ");
out.println(lock.getOwners());
}
else
{
out.println("No locks found");
}
}
catch (AVMNotFoundException avmerr)
{
out.println("No locks found");
}
}
else if (command[0].equals("deletenodeproperty"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fService.deleteNodeProperty(command[1], QName.createQName(command[2]));
out.println("deleted property " + command[2] + " of " + command[1]);
}
else if (command[0].equals("history"))
{
if (command.length != 4)
{
return "Syntax Error.";
}
AVMNodeDescriptor desc = fService.lookup(Integer.parseInt(command[2]), command[1]);
List<AVMNodeDescriptor> history = fService.getHistory(desc, Integer.parseInt(command[3]));
for (AVMNodeDescriptor node : history)
{
out.println(node);
out.println("Version: " + desc.getVersionID());
out.println("Owner: " + desc.getOwner());
out.println("Mod Time: " + new Date(desc.getModDate()));
}
}
/*
else if (command[0].equals("catver"))
{
if (command.length != 4)
{
return "Syntax Error.";
}
AVMNodeDescriptor desc = fService.lookup(Integer.parseInt(command[2]), command[1]);
List<AVMNodeDescriptor> history = fService.getHistory(desc, Integer.parseInt(command[3]));
if (history.size() == 0)
{
return "No History.";
}
BufferedReader reader =
new BufferedReader(
new InputStreamReader(
fService.getFileInputStream(history.get(history.size() - 1))));
String l;
while ((l = reader.readLine()) != null)
{
out.println(l);
}
reader.close();
}
*/
else if (command[0].equals("ca"))
{
if (command.length != 5)
{
return "Syntax Error.";
}
AVMNodeDescriptor left = fService.lookup(Integer.parseInt(command[2]), command[1]);
AVMNodeDescriptor right = fService.lookup(Integer.parseInt(command[4]), command[3]);
AVMNodeDescriptor ca = fService.getCommonAncestor(left, right);
out.println(ca);
}
else if (command[0].equals("statstore"))
{
if (command.length != 2)
{
return "Syntax Error.";
}
AVMStoreDescriptor desc = fService.getStore(command[1]);
if (desc == null)
{
return "Not Found.";
}
out.println(desc);
Map<QName, PropertyValue> props =
fService.getStoreProperties(command[1]);
for (QName name : props.keySet())
{
out.println(name + ": " + props.get(name));
}
}
else if (command[0].equals("compare"))
{
if (command.length != 5)
{
return "Syntax Error.";
}
List<AVMDifference> diffs = fSyncService.compare(Integer.parseInt(command[2]),
command[1],
Integer.parseInt(command[4]),
command[3],
null);
for (AVMDifference diff : diffs)
{
out.println(diff);
}
}
else if (command[0].equals("update"))
{
if (command.length != 4)
{
return "Syntax Error.";
}
AVMDifference diff = new AVMDifference(Integer.parseInt(command[2]), command[1],
-1, command[3], AVMDifference.NEWER);
List<AVMDifference> diffs = new ArrayList<AVMDifference>();
diffs.add(diff);
fSyncService.update(diffs, null, false, false, false, false, null, null);
}
else if (command[0].equals("resetLayer"))
{
if (command.length != 2)
{
return "Syntax Error.";
}
fSyncService.resetLayer(command[1]);
}
else if (command[0].equals("flatten"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fSyncService.flatten(command[1], command[2]);
}
else if (command[0].equals("getnodeaspects"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
final Set<QName> aspects = fService.getAspects(Integer.parseInt(command[2]), command[1]);
for (final QName qn : aspects)
{
out.println(qn.toString());
}
}
else if (command[0].equals("addnodeaspect"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fService.addAspect(command[1], QName.createQName(command[2]));
}
else if (command[0].equals("deletenodeaspect"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fService.removeAspect(command[1], QName.createQName(command[2]));
}
else if (command[0].equals("setnodeproperty"))
{
if (command.length < 4)
{
return "Syntax Error.";
}
QName valueQName = QName.createQName(command[2]);
String propertyValue = "";
// If multiple values are specified then concatenate the values
if (command.length > 4)
{
StringBuffer sb = new StringBuffer();
for (int i=3; i<command.length; i++)
{
sb.append(command[i]);
}
propertyValue = sb.toString();
}
else
{
propertyValue = command[3];
}
// Pass setNodeProperty() the serializable value
Serializable serializableValue = convertValueFromSring(propertyValue);
QName valueTypeQName = getValueTypeQName(propertyValue);
fService.setNodeProperty(command[1], valueQName, new PropertyValue(valueTypeQName, serializableValue));
out.println("set property " + command[2] + " of " + command[1]);
}
else if (command[0].equals("setstoreproperty"))
{
if (command.length < 4)
{
return "Syntax Error.";
}
QName valueQName = QName.createQName(command[2]);
String propertyValue = "";
// If multiple values are specified then concatenate the values
if (command.length > 4)
{
StringBuffer sb = new StringBuffer();
for (int i=3; i<command.length; i++)
{
sb.append(command[i]);
}
propertyValue = sb.toString();
}
else
{
propertyValue = command[3];
}
Serializable serializableValue = convertValueFromSring(propertyValue);
QName valueTypeQName = getValueTypeQName(propertyValue);
fService.setStoreProperty(command[1], valueQName, new PropertyValue(valueTypeQName, serializableValue));
out.println("set property " + command[2] + " of " + command[1]);
}
else if (command[0].equals("setstorepermission"))
{
if (command.length != 4)
{
return "Syntax Error.";
}
fPermissionService.setPermission(
new StoreRef(StoreRef.PROTOCOL_AVM, command[1]), command[2], command[3], true);
}
else if (command[0].equals("clearstorepermission"))
{
if (command.length != 3)
{
return "Syntax Error.";
}
fPermissionService.clearPermission(
new StoreRef(StoreRef.PROTOCOL_AVM, command[1]), command[2]);
}
// unknown or invalid command specified
else
{
return "Syntax Error.";
}
out.flush();
String retVal = new String(bout.toByteArray());
out.close();
return retVal;
}
catch (Exception e)
{
e.printStackTrace(System.err);
return e.toString();
}
}
private void recursiveList(PrintStream out, AVMNodeDescriptor dir, int indent)
{
Map<String, AVMNodeDescriptor> listing = fService.getDirectoryListing(dir, true);
for (String name : listing.keySet())
{
AVMNodeDescriptor child = listing.get(name);
for (int i = 0; i < indent; i++)
{
out.print(' ');
}
out.println(name + " " + child);
if (child.isDirectory())
{
recursiveList(out, child, indent + 2);
}
}
}
private static Serializable convertValueFromSring(String sValue)
{
Serializable retValue = "";
CharSequence seq = sValue.subSequence(0, sValue.length());
if (collectionPattern.matcher(seq).matches())
{
String[] elements = getCSVArray(sValue.substring(1, sValue.length()-1));
// Should this be an ArrayList or a HashSet?
Collection<Serializable> propValues = new HashSet<Serializable>(elements.length);
for (int i=0; i<elements.length; i++)
{
// Add each value in turn unless it is empty
if (!"".equals(elements[i]))
{
propValues.add(convertValueFromSring(elements[i]));
}
}
retValue = (Serializable)propValues;
}
else if (nodeRefPattern.matcher(seq).matches())
{
retValue = new NodeRef(sValue);
}
else if (integerPattern.matcher(seq).matches())
{
retValue = new Integer(sValue);
}
else if (dateTimePattern.matcher(seq).matches())
{
// TODO: Support timestamps
/*
DateFormat df = DateFormat.getDateTimeInstance(dateStyle, timeStyle)df.pa
Calendar cal = Calendar.getInstance();
retValue = new NodeRef(dateTimePattern.matcher(seq).group(1));
*/
} else
{
retValue = sValue;
}
return retValue;
}
private static QName getValueTypeQName(String sValue)
{
QName typeQName = null;
CharSequence seq = sValue.subSequence(0, sValue.length());
if (collectionPattern.matcher(seq).matches())
{
String[] elements = getCSVArray(sValue.substring(1, sValue.length()-1));
if (elements[0] != "")
{
typeQName = getValueTypeQName(elements[0]);
}
}
else if (nodeRefPattern.matcher(seq).matches())
{
typeQName = DataTypeDefinition.NODE_REF;
}
else if (integerPattern.matcher(seq).matches())
{
typeQName = DataTypeDefinition.INT;
}
else if (dateTimePattern.matcher(seq).matches())
{
// TODO: Support timestamps
/*
DateFormat df = DateFormat.getDateTimeInstance(dateStyle, timeStyle)df.pa
Calendar cal = Calendar.getInstance();
retValue = new NodeRef(dateTimePattern.matcher(seq).group(1));
*/
typeQName = DataTypeDefinition.DATETIME;
} else
{
typeQName = DataTypeDefinition.TEXT;
}
return typeQName;
}
private static String[] getCSVArray(String valueString)
{
String[] elements = valueString.split(",\\s+");
if (elements.length == 0)
{
elements = new String[1];
elements[0] = valueString;
}
return elements;
}
}