/*
* $Header: /home/cvs/jakarta-slide/src/stores/slidestore/file/Attic/UriProperties.java,v 1.8.2.3 2004/03/03 09:58:47 ozeigermann Exp $
* $Revision: 1.8.2.3 $
* $Date: 2004/03/03 09:58:47 $
*
* ====================================================================
*
* Copyright 1999-2002 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package slidestore.file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import org.apache.slide.common.ServiceAccessException;
import org.apache.slide.common.UnknownObjectClassException;
import org.apache.slide.common.Uri;
import org.apache.slide.content.NodeProperty;
import org.apache.slide.content.NodeRevisionDescriptor;
import org.apache.slide.content.NodeRevisionDescriptors;
import org.apache.slide.content.NodeRevisionNumber;
import org.apache.slide.lock.NodeLock;
import org.apache.slide.security.NodePermission;
import org.apache.slide.structure.LinkNode;
import org.apache.slide.structure.ObjectNode;
import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
/**
* Handles the saving and retreiving of descriptions attached to an Uri</a>
* @author <a href="mailto:mdecugis@mds-desing.fr">Marc D�cugis</a>
* @contact <a href="mailto:remm@apache.org">Remy Maucherat</a>
* @version $Revision: 1.8.2.3 $ , $Date: 2004/03/03 09:58:47 $
* @deprecated will be removed in 2.1
*/
public class UriProperties extends AbstractUriProperties {
/** A simple date format.*/
protected SimpleDateFormat dateFormat;
//----------------------------------------
public UriProperties(String aRootPath,Uri aUri) throws ServiceAccessException {
super(aRootPath,aUri);
dateFormat=new SimpleDateFormat("MM/dd/yyyy HH:mm:ss Z");
File aFile=getFile(aUri);
if (aFile.exists()) {
init(aFile);
}
}
// --------------------------------------
public static File getFile(String aRootPath,Uri aUri) {
// System.out.println("----------- UriProperties getFile 1/n aUri="+aUri);
// String aRelative = aUri.getRelative();
// // System.out.println("----------- UriProperties getFile 2/n aRelative="+aRelative);
// if (aRelative.equals("")) aRelative = "/";
// // System.out.println("----------- UriProperties getFile 3/n aRelative="+aRelative);
// File aFile = new File(rootpath + aRelative + ".def.xml");
File aFile = new File(aRootPath + aUri + ".def.xml");
File aParentFile = new File(aFile.getParent());
if ((aParentFile != null) && (!aParentFile.exists())) {
aParentFile.mkdirs();
}
return aFile;
}
// --------------------------------------
public File getFile(Uri aUri) {
return getFile(rootpath,aUri);
}
// --------------------------------------
public static XMLOutputter getXMLOutputter() {
XMLOutputter aOutputter = new XMLOutputter();
aOutputter.setEncoding("ISO-8859-1");//Unicode
aOutputter.setNewlines(true);
aOutputter.setIndent(" ");
aOutputter.setLineSeparator("\n");
//aOutputter.setTextNormalize(true);
return aOutputter;
}
// --------------------------------------
public static String booleanToString(boolean aBoolean) {
return aBoolean ? "true" : "false";
}
//----------------------------------------
//----------------------------------------
//----------------------------------------
//----------------------------------------
protected void save(Uri aUri) throws ServiceAccessException {
try {
File aFile=getFile(aUri);
// System.out.println("--------- save 1/n aFile="+aFile);
Element aRoot=encode();
// System.out.println("--------- save 2/n");
Document aDocument=new Document(aRoot);
// System.out.println("--------- save 3/n");
OutputStream aOut=new FileOutputStream(aFile);
XMLOutputter aOutputter = getXMLOutputter();
// aOutputter.output(aDocument, // System.out);
aOutputter.output(aDocument, aOut);
// if (DEBUG) trace("--------- enregistre 3/n");
// System.out.println("--------- save 4/n");
aOut.flush();
aOut.close();
// System.out.println("--------- save 5/n");
}
catch (Exception e) {
e.printStackTrace();
throw new ServiceAccessException(null,e);
}
}
//----------------------------------------
protected Element encode() throws ServiceAccessException {
Element aRoot=new Element("data");
aRoot.addContent(encodeObject());
aRoot.addContent(encodePermissions());
aRoot.addContent(encodeLocks());
aRoot.addContent(encodeRevisionDescriptors());
aRoot.addContent(encodeRevisionDescriptor());
return aRoot;
}
// --------------------------------------
public Element encodeObject() {
Element aElementObjectNode=new Element("objectnode");
aElementObjectNode.setAttribute("classname",object.getClass().getName());
aElementObjectNode.setAttribute("uri",object.getUri());
aElementObjectNode.addContent(createBindings("children", "child", object.enumerateBindings()));
aElementObjectNode.addContent(createBindings("parents", "parent", object.enumerateParentBindings()));
aElementObjectNode.addContent(createElements("links","link",object.enumerateLinks()));
if (object instanceof LinkNode) {
aElementObjectNode.setAttribute("linkTo",((LinkNode)object).getLinkedUri());
}
return aElementObjectNode;
}
// --------------------------------------
private Element createBindings(String aParent, String aChild, Enumeration aEnum) {
Element aElement=new Element(aParent);
Element childNode;
ObjectNode.Binding binding;
while (aEnum.hasMoreElements()) {
binding = (ObjectNode.Binding) aEnum.nextElement();
childNode = new Element(aChild);
childNode.setAttribute(new Attribute("name", binding.getName()));
childNode.setAttribute(new Attribute("uuri", binding.getUuri()));
aElement.addContent(childNode);
}
return aElement;
}
// --------------------------------------
public Element encodePermissions() {
Element aPermissions=new Element("permissions");
if (permissions==null) return aPermissions;
for (int aSize=permissions.size(),i=0;i<aSize;i++) {
NodePermission aPermission=(NodePermission)permissions.elementAt(i);
aPermissions.addContent(encodeNodePermission(aPermission));
}
return aPermissions;
}
// --------------------------------------
public Element encodeNodePermission(NodePermission aPermission) {
Element aElementPermission=new Element("permission");
NodeRevisionNumber aRevisionNumber=aPermission.getRevisionNumber();
if (aRevisionNumber!=null) {
aElementPermission.setAttribute("revisionNumber",encodeRevisionNumber(aRevisionNumber));
}
aElementPermission.setAttribute("subjectUri",aPermission.getSubjectUri());
aElementPermission.setAttribute("actionUri",aPermission.getActionUri());
aElementPermission.setAttribute("inheritable",booleanToString(aPermission.isInheritable()));
aElementPermission.setAttribute("negative",booleanToString(aPermission.isNegative()));
return aElementPermission;
}
// --------------------------------------
public Element encodeLocks() {
Element aElementLocks=new Element("locks");
if (locks==null) return aElementLocks;
for (int aSize=locks.size(),i=0;i<aSize;i++) {
NodeLock aLock=(NodeLock)locks.elementAt(i);
Element aElementLock=new Element("lock");
aElementLock.setAttribute("subjectUri",aLock.getSubjectUri());
aElementLock.setAttribute("typeUri",aLock.getTypeUri());
aElementLock.setAttribute("date",dateFormat.format(aLock.getExpirationDate()));
aElementLock.setAttribute("inheritance",booleanToString(aLock.isInheritable()));
aElementLock.setAttribute("exclusive",booleanToString(aLock.isExclusive()));
aElementLock.setAttribute("lockId",aLock.getLockId());
aElementLock.setAttribute("owner",aLock.getOwnerInfo());
aElementLocks.addContent(aElementLock);
}
return aElementLocks;
}
// --------------------------------------
public Element encodeRevisionDescriptors() {
Element aRevisionsHistory=new Element("revisionsHistory");
if (revisionDescriptors==null) return aRevisionsHistory;
aRevisionsHistory.setAttribute("initialRevision",encodeRevisionNumber(revisionDescriptors.getInitialRevision()));
aRevisionsHistory.setAttribute("useVersioning",booleanToString(revisionDescriptors.isVersioned()));
// System.out.println("---------- encodeRevisionDescriptors getLatestRevision="+
// revisionDescriptors.getLatestRevision());
Element aBranchesElement=new Element("branches");
Enumeration aBranches=revisionDescriptors.enumerateBranchNames();
while (aBranches.hasMoreElements()) {
String aBranchName=(String)aBranches.nextElement();
Element aElementBranch=new Element("branch");
aElementBranch.setAttribute("name",aBranchName);
NodeRevisionNumber aRevisionNumber=revisionDescriptors.getLatestRevision(aBranchName);
aElementBranch.setAttribute("lastestRevision",encodeRevisionNumber(aRevisionNumber));
aBranchesElement.addContent(aElementBranch);
}
aRevisionsHistory.addContent(aBranchesElement);
Element aRevisionsElement=new Element("revisions");
Enumeration aRevisions=revisionDescriptors.enumerateRevisionNumbers();
while (aRevisions.hasMoreElements()) {
NodeRevisionNumber aRevisionNumber=(NodeRevisionNumber)aRevisions.nextElement();
Element aRevisionElement=new Element("branch");
aRevisionElement.setAttribute("start",encodeRevisionNumber(aRevisionNumber));
Enumeration aSuccessors=revisionDescriptors.getSuccessors(aRevisionNumber);
while (aSuccessors.hasMoreElements()) {
NodeRevisionNumber aSuccessorRevisionNumber=(NodeRevisionNumber)aSuccessors.nextElement();
Element aSuccessorRevisionElement=new Element("revision");
aSuccessorRevisionElement.setAttribute("number",encodeRevisionNumber(aSuccessorRevisionNumber));
aRevisionElement.addContent(aSuccessorRevisionElement);
}
aRevisionsElement.addContent(aRevisionElement);
}
aRevisionsHistory.addContent(aRevisionsElement);
return aRevisionsHistory;
}
// --------------------------------------
public Element encodeRevisionDescriptor() {
Element aRet=new Element("descriptor");
if (descriptor==null) return aRet;
for (Enumeration aEnum=descriptor.elements();aEnum.hasMoreElements();) {
NodeRevisionDescriptor aRevisionDescriptor=(NodeRevisionDescriptor)aEnum.nextElement();
aRet.addContent(encodeRevisionDescriptor(aRevisionDescriptor));
}
return aRet;
}
// --------------------------------------
public Element encodeRevisionDescriptor(NodeRevisionDescriptor aDescriptor) {
Element aRevisions=new Element("revisions");
aRevisions.setAttribute("branchName",aDescriptor.getBranchName());
aRevisions.setAttribute("number",encodeRevisionNumber(aDescriptor.getRevisionNumber()));
aRevisions.addContent(createElements("labels","label",aDescriptor.enumerateLabels()));
Element aProperties=new Element("properties");
for (Enumeration aEnum=aDescriptor.enumerateProperties();aEnum.hasMoreElements();) {
Object aObject=aEnum.nextElement();
// System.out.println("---------- encodeRevisionDescriptor aObject="+aObject+" "+aObject.getClass().getName());
NodeProperty aProp=(NodeProperty)aObject;
aProperties.addContent(encodeNodeProperty(aProp));
}
aRevisions.addContent(aProperties);
return aRevisions;
}
// --------------------------------------
public String encodeRevisionNumber(NodeRevisionNumber aRevisionNumber) {
return aRevisionNumber.getMajor()+"."+aRevisionNumber.getMinor();
}
// --------------------------------------
public Element encodeNodeProperty(NodeProperty aProp) {
Element aElement=new Element("property");
aElement.setAttribute("name",aProp.getName());
aElement.setAttribute("namespace",aProp.getNamespace());
aElement.setAttribute("value",aProp.getValue().toString());
aElement.setAttribute("type",aProp.getType());
aElement.setAttribute("protected",booleanToString(aProp.isProtected()));
Element aPermissions=new Element("permissions");
for (Enumeration aEnum=aProp.enumeratePermissions();aEnum.hasMoreElements();) {
NodePermission aPermission=(NodePermission)aEnum.nextElement();
aPermissions.addContent(encodeNodePermission(aPermission));
}
aElement.addContent(aPermissions);
return aElement;
}
// --------------------------------------
public Element createElements(String aParent,String aChild,Enumeration aEnum) {
Element aElement=new Element(aParent);
while (aEnum.hasMoreElements()) {
Object aObject=aEnum.nextElement();
Element aItem=new Element(aChild);
aItem.setAttribute("val",aObject.toString());
aElement.addContent(aItem);
}
return aElement;
}
//----------------------------------------
//----------------------------------------
//----------------------------------------
//----------------------------------------
protected void init(File aFile) throws ServiceAccessException {
try {
// System.out.println("--------- init 1/n aFile="+aFile);
SAXBuilder aBuilder=new SAXBuilder();
FileInputStream aIn=new FileInputStream(aFile);
Document aDocument=aBuilder.build(aIn);
// System.out.println("--------- init 2/n");
decode(aDocument.getRootElement());
// System.out.println("--------- init 3/n");
aIn.close();
// System.out.println("--------- init 5/n");
}
catch (Exception e) {
e.printStackTrace();
throw new ServiceAccessException(null,e);
}
}
//----------------------------------------
protected void decode(Element aRoot) throws ServiceAccessException {
decodeObject(aRoot);
decodePermissions(aRoot);
decodeLocks(aRoot);
decodeRevisionDescriptors(aRoot);
decodeRevisionDescriptor(aRoot);
}
// --------------------------------------
public void decodeObject(Element aElement) throws ServiceAccessException {
try {
Element aElementObjectNode=aElement.getChild("objectnode");
String aClasseName=aElementObjectNode.getAttributeValue("classname");
String aUri=aElementObjectNode.getAttributeValue("uri");
Vector aChilds=createBindingVector(aElementObjectNode,"children","child",false);
Vector aParents=createBindingVector(aElementObjectNode,"parents","parent",true);
Vector aLinks=createVector(aElementObjectNode,"links","link");
// System.out.println("--------- decodeObject aChilds="+aChilds);
// System.out.println("--------- decodeObject aLinks="+aLinks);
Class aTypes[] = null;
Object aArgs[] = null;
if (aClasseName.equals(LinkNode.class.getName())) {
String aLinkTo=aElementObjectNode.getAttributeValue("linkTo");
aTypes= new Class[]{String.class,Vector.class,Vector.class,String.class};
aArgs= new Object[]{aUri, aChilds, aLinks,aLinkTo};
}
else {
aTypes=new Class[] {String.class,Vector.class,Vector.class,Vector.class};
aArgs=new Object[] {aUri, aChilds, aParents, aLinks};
}
object=(ObjectNode) createObject(aClasseName,aTypes,aArgs);
object.setUri(object.getUuri());
}
catch (Exception e) {
e.printStackTrace();
throw new ServiceAccessException(null,e);
}
}
// --------------------------------------
public void decodePermissions(Element aElement) {
permissions=new Vector();
String aUri=object.getUri().toString();
Element aPermissions=aElement.getChild("permissions");
List aList=aPermissions.getChildren();
for (int i=0;i<aList.size();i++) {
Element aChild=(Element)aList.get(i);
permissions.addElement(decodePermission(aChild,aUri));
}
}
// --------------------------------------
public void decodeLocks(Element aElement) throws ServiceAccessException {
try {
locks=new Vector();
Element aElementLocks=aElement.getChild("locks");
List aList=aElementLocks.getChildren();
for (int i=0;i<aList.size();i++) {
Element aChild=(Element)aList.get(i);
String aSubject=aChild.getAttributeValue("subjectUri");
String aType=aChild.getAttributeValue("typeUri");
Date aDateExpiration=dateFormat.parse(aChild.getAttributeValue("date"));
boolean aInheritable=new Boolean(aChild.getAttributeValue("inheritance")).booleanValue();
boolean aNegative=new Boolean(aChild.getAttributeValue("exclusive")).booleanValue();
String aLockId=aChild.getAttributeValue("lockId");
locks.addElement(
new NodeLock(aLockId,object.getUri(),aSubject,aType,aDateExpiration,aInheritable,aNegative)
);
}
}
catch (Exception e) {
e.printStackTrace();
throw new ServiceAccessException(null,e);
}
}
// --------------------------------------
public void decodeRevisionDescriptors(Element aElement) {
Element aRevisionsHistory=aElement.getChild("revisionsHistory");
NodeRevisionNumber aInitialRevision=decodeRevisionNumber(aRevisionsHistory.getAttributeValue("initialRevision"));
boolean aUseVersionning=new Boolean(aRevisionsHistory.getAttributeValue("useVersioning")).booleanValue();
Element aBranchesElement=aRevisionsHistory.getChild("branches");
if (aBranchesElement==null) {
revisionDescriptors=new NodeRevisionDescriptors(
object.getUri().toString(),aInitialRevision,new Hashtable(),new Hashtable(),new Hashtable(),aUseVersionning);
return;
}
List aList=aBranchesElement.getChildren();
Hashtable aLastestRevisions=new Hashtable();
for (int i=0;i<aList.size();i++) {
Element aChild=(Element)aList.get(i);
String aName=aChild.getAttributeValue("name");
NodeRevisionNumber aRevisionNumber=decodeRevisionNumber(aChild.getAttributeValue("lastestRevision"));
aLastestRevisions.put(aName,aRevisionNumber);
}
Hashtable aBranches=new Hashtable();
Element aRevisionsElement=aRevisionsHistory.getChild("revisions");
aList=aRevisionsElement.getChildren();
for (int i=0;i<aList.size();i++) {
Element aChild=(Element)aList.get(i);
NodeRevisionNumber aStartNumber=decodeRevisionNumber(aChild.getAttributeValue("start"));
List aSuccessors=aChild.getChildren();
Vector aSuccessorsNumbers=new Vector();
for (int k=0;k<aSuccessors.size();k++) {
Element aSuccessor=(Element)aSuccessors.get(k);
NodeRevisionNumber aRevisionNumber=decodeRevisionNumber(aSuccessor.getAttributeValue("number"));
aSuccessorsNumbers.addElement(aRevisionNumber);
}
aBranches.put(aStartNumber,aSuccessorsNumbers);
}
revisionDescriptors=new NodeRevisionDescriptors(
object.getUri().toString(),aInitialRevision,new Hashtable(),aLastestRevisions,aBranches,aUseVersionning);
}
// --------------------------------------
public void decodeRevisionDescriptor(Element aParent) {
descriptor=new Hashtable();
Element aElement=aParent.getChild("descriptor");
if (aElement==null) return;
List aList=aElement.getChildren();
String aUri=object.getUri().toString();
for (int i=0;i<aList.size();i++) {
Element aChild=(Element)aList.get(i);
String aBranchName=aChild.getAttributeValue("branchName");
NodeRevisionNumber aRevisionNumber=decodeRevisionNumber(aChild.getAttributeValue("number"));
Vector aLabels=new Vector();
Element aLabelsElement=(Element)aChild.getChild("labels");
List aLabelList=aLabelsElement.getChildren();
for (int k=0;k<aLabelList.size();k++) {
Element aLabel=(Element)aLabelList.get(k);
aLabels.addElement(aLabel.getAttributeValue("val"));
}
Hashtable aProperties=new Hashtable();
Element aPropertiesElement=(Element)aChild.getChild("properties");
List aPropertiesList=aPropertiesElement.getChildren();
for (int k=0;k<aPropertiesList.size();k++) {
Element aProperty=(Element)aPropertiesList.get(k);
NodeProperty aProp=decodeNodeProperty(aProperty,aUri);
String key =
aProperty.getAttributeValue("namespace")+aProperty.getAttributeValue("name");
aProperties.put(key,aProp);
}
NodeRevisionDescriptor aNode=new NodeRevisionDescriptor(aRevisionNumber,aBranchName,aLabels,aProperties);
descriptor.put(aRevisionNumber.toString(),aNode);
}
}
// --------------------------------------
public NodePermission decodePermission(Element aElement,String aUri) {
String aRevisionNumber=aElement.getAttributeValue("revisionNumber");
String aSubject=aElement.getAttributeValue("subjectUri");
String aAction=aElement.getAttributeValue("actionUri");
boolean aInheritable=new Boolean(aElement.getAttributeValue("inheritable")).booleanValue();
boolean aNegative=new Boolean(aElement.getAttributeValue("negative")).booleanValue();
return new NodePermission(aUri,aRevisionNumber,aSubject,aAction,aInheritable,aNegative);
}
// --------------------------------------
public NodeRevisionNumber decodeRevisionNumber(Element aElement) {
Element aElementRevision=aElement.getChild("revision");
return new NodeRevisionNumber(Integer.parseInt(aElementRevision.getAttributeValue("major")),
Integer.parseInt(aElementRevision.getAttributeValue("minor")));
}
// --------------------------------------
public NodeRevisionNumber decodeRevisionNumber(String aStr) {
return (aStr==null ? null : new NodeRevisionNumber(aStr));
}
// --------------------------------------
public NodeProperty decodeNodeProperty(Element aElement,String aUri) {
String aName=aElement.getAttributeValue("name");
String aValue=aElement.getAttributeValue("value");
String aNamespace=aElement.getAttributeValue("namespace");
String aType=aElement.getAttributeValue("type");
boolean aProtected=new Boolean(aElement.getAttributeValue("protected")).booleanValue();
Element aPermisionsElement=aElement.getChild("permissions");
List aList=aPermisionsElement.getChildren();
Vector aPermission=new Vector();
for (int i=0;i<aList.size();i++) {
Element aChild=(Element)aList.get(i);
aPermission.addElement(decodePermission(aChild,aUri));
}
return new NodeProperty(aName,aValue,aNamespace,aType,aProtected);
}
// --------------------------------------
public Vector createVector(Element aElement,String aParentName,String aChildName) {
Element aParent=aElement.getChild(aParentName);
Vector aRet=new Vector();
// System.out.println("--------- createVector aParentName="+aParentName+" aChildName="+aChildName);
List aList=aParent.getChildren(aChildName);
// System.out.println("--------- createVector aList="+aList);
for (int i=0;i<aList.size();i++) {
Element aChild=(Element)aList.get(i);
aRet.addElement(aChild.getAttributeValue("val"));
}
return aRet;
}
// --------------------------------------
public Vector createBindingVector(Element aElement,String aParentName,String aChildName,boolean parentBindings) {
Element aParent=aElement.getChild(aParentName);
Vector aRet=new Vector();
// System.out.println("--------- createVector aParentName="+aParentName+" aChildName="+aChildName);
Iterator it = aParent.getChildren().iterator();
while (it.hasNext()) {
Element aChild = (Element)it.next();
String name = aChild.getAttributeValue("name");
String uuri = aChild.getAttributeValue ("uuri");
if (parentBindings) {
aRet.add(new ObjectNode.ParentBinding(name, uuri));
}
else {
aRet.add(new ObjectNode.Binding(name, uuri));
}
}
return aRet;
}
// --------------------------------------
public Object createObject(String aNomClasse,Class aTypes[],Object aArgs[]) throws UnknownObjectClassException {
Class aClasse = null;
try {
// First, load the object's class
aClasse = Class.forName(aNomClasse);
Constructor aConstructor = aClasse.getConstructor(aTypes);
if (aConstructor==null) aConstructor=aClasse.getSuperclass().getConstructor(aTypes);
return aConstructor.newInstance(aArgs);
}
catch (Exception e) {
throw new UnknownObjectClassException(aNomClasse);
}
}
/*
// --------------------------------------
public Vector decodeObject(Vector aVector,Enumeration aEnum) {
}
*/
}