protected void sendNotification(
ServerRequestContext context,
NotifyActionType notifyAction,
NotificationType notification,
AuditableEventType ae)
throws RegistryException {
System.err.println("Sending notification to web service");
try {
// Get the ServiceBinding id that represents the endPoint
String endPoint = notifyAction.getEndPoint();
// Now get the ServiceBinding and its acceessURI
ServiceBindingType serviceBinding =
(ServiceBindingType)
PersistenceManagerFactory.getInstance()
.getPersistenceManager()
.getRegistryObject(context, endPoint, "ServiceBinding");
String accessURI = serviceBinding.getAccessURI();
NotificationListenerPortType_Stub stub =
(NotificationListenerPortType_Stub)
(new NotificationListenerSOAPService_Impl().getNotificationListenerPort());
((Stub) stub)._setProperty(javax.xml.rpc.Stub.ENDPOINT_ADDRESS_PROPERTY, accessURI);
javax.xml.bind.Marshaller marshaller =
BindingUtility.getInstance().getJAXBContext().createMarshaller();
marshaller.setProperty(javax.xml.bind.Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
marshaller.marshal(notification, System.err);
SOAPElement soapElem =
BindingUtility.getInstance().getSOAPElementFromBindingObject(notification);
String notificationOption = notifyAction.getNotificationOption();
if (notificationOption.equals(BindingUtility.CANONICAL_NOTIFICATION_OPTION_TYPE_ID_Objects)) {
stub.onObjectsNotification(soapElem);
} else if (notificationOption.equals(
BindingUtility.CANONICAL_NOTIFICATION_OPTION_TYPE_ID_ObjectRefs)) {
stub.onObjectRefsNotification(soapElem);
}
} catch (Exception e) {
e.printStackTrace();
throw new RegistryException(e);
}
}
/**
* @author Farrukh S. Najmi
* <p>This class handles version management for RegistryObjects and RepositoryItems.
*/
public class VersionProcessor {
public static BindingUtility bu = BindingUtility.getInstance();
private static Log log = LogFactory.getLog(VersionProcessor.class);
private QueryManager qm = QueryManagerFactory.getInstance().getQueryManager();
private AuthenticationServiceImpl ac = AuthenticationServiceImpl.getInstance();
private RepositoryManager rm = RepositoryManagerFactory.getInstance().getRepositoryManager();
private HashSet versionableClassNameSet = new HashSet();
private List versions;
/** @associates <{org.freebxml.omar.server.persistence.PersistenceManagerImpl}> */
PersistenceManager pm = PersistenceManagerFactory.getInstance().getPersistenceManager();;
ServerRequestContext context = null;
/** Creates a new instance of VersionManagerImpl */
public VersionProcessor(ServerRequestContext context) {
this.context = context;
loadVersionableClasses();
}
public boolean needToVersionRegistryObject(RegistryObjectType ro) throws RegistryException {
boolean needToVersion = true;
BindingUtility bu = BindingUtility.getInstance();
boolean newObject = false;
try {
needToVersion = isVersionableClass(ro);
if (needToVersion) {
HashMap slotsMap;
// Honour dontVersion flag if specified on request
if (!context.getRegistryRequestStack().empty()) {
slotsMap = bu.getSlotsFromRequest(context.getCurrentRegistryRequest());
if (slotsMap.containsKey(bu.CANONICAL_SLOT_LCM_DONT_VERSION)) {
String val = (String) slotsMap.get(bu.CANONICAL_SLOT_LCM_DONT_VERSION);
if (val.trim().equalsIgnoreCase("true")) {
needToVersion = false;
}
}
}
// Honour dontVersion flag if specified on ro
slotsMap = bu.getSlotsFromRegistryObject(ro);
if (slotsMap.containsKey(bu.CANONICAL_SLOT_LCM_DONT_VERSION)) {
String val = (String) slotsMap.get(bu.CANONICAL_SLOT_LCM_DONT_VERSION);
if (val.trim().equalsIgnoreCase("true")) {
needToVersion = false;
}
}
}
// TODO:
// Need to investigate case where not versioning and it is a new object.
// Need unit test for this case.
if (needToVersion) {
versions = getAllRegistryObjectVersions(ro);
if (versions.size()
== 0) { // If there are any existing versions (ie. ro's with same LID) then we need to
// version
// This is a new ro and therefor need not be versioned
needToVersion = false;
newObject = true;
}
}
// Must set versionName to match latest versionName if existing object
// or set to version 1.1 if new object.
if (!needToVersion) {
RegistryObjectType lastVersion = getLatestVersionOfRegistryObject(ro);
String versionName = null;
if (lastVersion == null) {
versionName = "1.1";
} else {
versionName = lastVersion.getVersionInfo().getVersionName();
// Must bump up versionName for new objects
if (newObject) {
versionName = nextVersion(versionName);
}
}
VersionInfoType versionInfo = ro.getVersionInfo();
if (versionInfo == null) {
versionInfo = bu.rimFac.createVersionInfoType();
ro.setVersionInfo(versionInfo);
}
versionInfo.setVersionName(versionName);
if (!context.getRegistryRequestStack().empty()) {
setVersionInfoComment(versionInfo);
}
}
} catch (JAXBException e) {
throw new RegistryException(e);
}
return needToVersion;
}
private void setVersionInfoComment(VersionInfoType versionInfo) {
String requestComment = context.getCurrentRegistryRequest().getComment();
if (versionInfo.getComment() == null && requestComment != null) {
versionInfo.setComment(requestComment);
}
}
public void checkRegistryObjectLid(RegistryObjectType ro) throws RegistryException {
String id = ro.getId();
String lid = ro.getLid();
String existingObjectLid = (String) context.getIdToLidMap().get(id);
// Assign lid if not specified, validate lid if specified
if (existingObjectLid != null) {
if (lid == null) {
ro.setLid(existingObjectLid);
} else {
// Validate that lid matches existing objects lid
if (!lid.equals(existingObjectLid)) {
throw new RegistryException(
ServerResourceBundle.getInstance()
.getString("message.idDoesNotMatch", new Object[] {lid, existingObjectLid, id}));
}
}
} else {
checkRegistryObjectLidOnNewObject(ro);
}
}
public void checkRegistryObjectLidOnNewObject(RegistryObjectType ro) throws RegistryException {
String id = ro.getId();
String lid = ro.getLid();
// Object does not exists already
if (lid == null) {
ro.setLid(ro.getId());
}
}
public boolean needToVersionRepositoryItem(ExtrinsicObjectType eo, RepositoryItem riNew)
throws RegistryException {
boolean needToVersion = true;
try {
// dontVersion eo imples dontVersion ro
needToVersion = needToVersionRegistryObject(eo);
if (needToVersion) {
// This is an existing object not a newly submitted object
// See if repository item has changed or not.
HashMap slotsMap;
// Honour dontVersion flag if specified on request
if (!context.getRegistryRequestStack().empty()) {
slotsMap = bu.getSlotsFromRequest(context.getCurrentRegistryRequest());
if (slotsMap.containsKey(bu.CANONICAL_SLOT_LCM_DONT_VERSION_CONTENT)) {
String val = (String) slotsMap.get(bu.CANONICAL_SLOT_LCM_DONT_VERSION_CONTENT);
if (val.trim().equalsIgnoreCase("true")) {
needToVersion = false;
}
}
}
// Honour dontVersion flag if specified on ro
slotsMap = bu.getSlotsFromRegistryObject(eo);
if (slotsMap.containsKey(bu.CANONICAL_SLOT_LCM_DONT_VERSION_CONTENT)) {
String val = (String) slotsMap.get(bu.CANONICAL_SLOT_LCM_DONT_VERSION_CONTENT);
if (val.trim().equalsIgnoreCase("true")) {
needToVersion = false;
}
}
}
if (needToVersion) {
if (riNew == null) {
needToVersion = false;
return needToVersion;
} else {
RepositoryItem riOld = null;
try {
riOld = rm.getRepositoryItem(eo.getId());
} catch (RepositoryItemNotFoundException e) {
// It is possible that there is no RepositoryItem yet.
// Ignore the exception.
} catch (ObjectNotFoundException e) {
// It is possible that there is no RepositoryItem yet.
// Ignore the exception.
}
if (riOld == null) {
needToVersion = false;
} else {
if (repositoryItemsAreIdentical(riOld, riNew)) {
needToVersion = false;
}
}
}
}
// Must set contentVersionName to match latest versionName if existing object
// or set to version 1.1 if new object.
if (!needToVersion) {
ExtrinsicObjectType lastVersion =
(ExtrinsicObjectType) getLatestVersionOfRegistryObject(eo);
VersionInfoType contentVersionInfo = eo.getContentVersionInfo();
if (contentVersionInfo == null) {
contentVersionInfo = bu.rimFac.createVersionInfoType();
}
if (lastVersion == null) {
// This is the first ExtrinsicObject version.
if (riNew != null) {
// This is the first RepositoryItem version. Make sure versionName is "1.1"
contentVersionInfo.setVersionName("1.1");
} else {
// No repository item means that the contentVersionInfo MUST be set to null
contentVersionInfo = null;
}
} else {
// This is not the first ExtrinsicObject version.
// Note that contentversionName is set even if no RI is submitted since
// it is OK to update just the EO and have new version use last version of RO
VersionInfoType lastContentVersionInfo = lastVersion.getContentVersionInfo();
if (lastContentVersionInfo == null) {
// Previous version had no repository item
String lastContentVersionName = rm.getLatestVersionName(context, eo.getLid());
if (lastContentVersionName != null) {
contentVersionInfo.setVersionName(lastContentVersionName);
} else {
contentVersionInfo.setVersionName("1.1");
}
} else {
// Previous version had a repository item
// Use the last contentVersionName
contentVersionInfo.setVersionName(lastContentVersionInfo.getVersionName());
}
}
eo.setContentVersionInfo(contentVersionInfo);
}
} catch (JAXBException e) {
throw new RegistryException(e);
}
return needToVersion;
}
/**
* Creates a new version of the RepositoryItem associated with specified ExtrinsicObject. Note
* that when the RepositoryItem is versioned its ExtrinsicObject must also be versioned.
*/
public RepositoryItem createRepositoryItemVersion(ExtrinsicObjectType eo)
throws RegistryException {
RepositoryItem riNew = null;
try {
ExtrinsicObjectType eoNew = (ExtrinsicObjectType) createRegistryObjectVersion(eo);
String latestContentVersionName = rm.getLatestVersionName(context, eo.getLid());
String nextContentVersionName = nextVersion(latestContentVersionName);
VersionInfoType nextContentVersionInfo = bu.rimFac.createVersionInfoType();
nextContentVersionInfo.setVersionName(nextContentVersionName);
// Set the contentComment from the submitted object's contentVersionInfo
VersionInfoType submittedContentVersionInfo = eo.getContentVersionInfo();
if (submittedContentVersionInfo != null) {
nextContentVersionInfo.setComment(submittedContentVersionInfo.getComment());
}
// Update the eo contentVersionName to match newContentVersionName
eoNew.setContentVersionInfo(nextContentVersionInfo);
RepositoryItem riOld = (RepositoryItem) context.getRepositoryItemsMap().get(eo.getId());
riNew = (RepositoryItem) riOld.clone();
// A new version must have a unique id that matches its new ExtrinsicObject eoNew
riNew.setId(eoNew.getId());
// Now remeber in context.newRIVersionMap fro later replacement
// Should we be using old or new eo.getId().
// Maybe we dont need newRIVersionMap and newROVersionMap
// Lets see how to just use existing idMap and other structures.
context.getNewRIVersionMap().put(context.getRepositoryItemsMap().get(eo.getId()), riNew);
} catch (CloneNotSupportedException e) {
// This cannot happen
throw new RegistryException(e);
} catch (JAXBException e) {
throw new RegistryException(e);
}
return riNew;
}
private List getAllRegistryObjectVersions(RegistryObjectType ro) throws RegistryException {
if (versions == null) {
ServerRequestContext queryContext = null;
// Note: ORDER BY versionName DESC is not safe because String(1.10) < String(1.9)
String query =
"SELECT ro.* FROM "
+ Utility.getInstance().mapTableName(ro)
+ " ro WHERE ro.lid = '"
+ ro.getLid()
+ "'";
try {
AdhocQueryRequest queryRequest = bu.createAdhocQueryRequest(query);
queryContext =
new ServerRequestContext("VersionProcessor.getAllRegistryObjectVersions", queryRequest);
queryContext.setUser(ac.registryOperator);
AdhocQueryResponseType queryResp = qm.submitAdhocQuery(queryContext);
versions = queryResp.getRegistryObjectList().getIdentifiable();
queryContext.commit();
queryContext = null;
} catch (JAXBException e) {
throw (new RegistryException(e));
} catch (JAXRException e) {
throw (new RegistryException(e));
} finally {
if (queryContext != null) {
queryContext.rollback();
}
}
}
return (versions);
}
private RegistryObjectType getLatestVersionOfRegistryObject(RegistryObjectType ro)
throws RegistryException {
RegistryObjectType latestRO = null;
// Call in case versions have not been initialized yet.
getAllRegistryObjectVersions(ro);
if (versions.size() == 0) {
return null;
}
String latestVersion = null;
for (Iterator it = versions.iterator(); it.hasNext(); ) {
if (latestRO == null) {
latestRO = (RegistryObjectType) it.next();
latestVersion = latestRO.getVersionInfo().getVersionName();
continue;
}
RegistryObjectType next = (RegistryObjectType) it.next();
String nextVersion = next.getVersionInfo().getVersionName();
if (compareVersions(nextVersion, latestVersion) > 0) {
latestRO = next;
latestVersion = latestRO.getVersionInfo().getVersionName();
}
}
return latestRO;
}
// TODO: Consider replacing versions with idToVersionsMap as a performance optimization in future.
private boolean isIdInVersions(String id) {
RegistryObjectType ro = null;
boolean foundId = false;
if (versions != null) {
Iterator iter = versions.iterator();
while (iter.hasNext()) {
ro = (RegistryObjectType) iter.next();
if (id.equals(ro.getId())) {
foundId = true;
break;
}
}
}
return (foundId);
}
/**
* Compares 2 version Strings, with major/minor versions separated by '.' Example: "1.10"
*
* @param v1 String for version 1.
* @param v2 String for version 2.
* @return int = 0 if params are equal; int > 0 if 1st is grater than 2nd; int < 0 if 2st is
* grater than 1nd.
*/
public static int compareVersions(String v1, String v2) {
String parts1[] = v1.split("\\.", 2);
String parts2[] = v2.split("\\.", 2);
int iCompare = Integer.parseInt(parts1[0]) - Integer.parseInt(parts2[0]);
if (iCompare == 0) {
// equal.. try subversions
if (parts1.length == 1 && parts2.length == 1) {
// really equal
return 0;
} else if (parts1.length == 1) {
// other is bigger (v2)
return -1;
} else if (parts2.length == 1) {
// other is bigger (v1)
return +1;
} else {
// try subversions
return compareVersions(parts1[1], parts2[1]);
}
} else {
return iCompare;
}
}
public RegistryObjectType createRegistryObjectVersion(RegistryObjectType ro)
throws RegistryException {
RegistryObjectType roNew = null;
try {
Utility util = Utility.getInstance();
RegistryObjectType lastVersion = getLatestVersionOfRegistryObject(ro);
String nextVersion = null;
if (lastVersion == null) {
nextVersion = "1.1";
} else {
nextVersion = nextVersion(lastVersion.getVersionInfo().getVersionName());
}
roNew = bu.cloneRegistryObject(ro);
VersionInfoType nextVersionInfo = bu.rimFac.createVersionInfoType();
nextVersionInfo.setVersionName(nextVersion);
// Set the comment from the request comment (per the spec)
if (!context.getRegistryRequestStack().empty()) {
nextVersionInfo.setComment(context.getCurrentRegistryRequest().getComment());
}
roNew.setVersionInfo(nextVersionInfo);
// A new version must have a unique id
String id = ro.getId();
String lid = ro.getLid();
String idNew = id;
// Only change id if it already exists in versions
// Need to preserve client supplied id in the case where lid is an
// existing lid but id is new
if (isIdInVersions(id)) {
// Make id of next version be lid with ":nextVersion" as suffix, if this id is already in
// use in a version
idNew = lid + ":" + nextVersion; // Utility.getInstance().createId();
roNew.setId(idNew);
// Add entry to idMap so old id and refs to it are mapped to idNew
context.getIdMap().put(id, idNew);
}
// Add entry to context.newROVersionMap for later replacement
context.getNewROVersionMap().put(ro, roNew);
// Assign new ids to all composed RegistryObjects within roNew
Set composedObjects = bu.getComposedRegistryObjects(roNew, -1);
Iterator iter = composedObjects.iterator();
while (iter.hasNext()) {
RegistryObjectType composedObject = (RegistryObjectType) iter.next();
// check for composed object if exist change the id and lid and
// also update the idMap.
if (objectExists(composedObject.getId())) {
String oldId = composedObject.getId();
String newId = oldId + ":" + nextVersion;
composedObject.setId(newId);
composedObject.setLid(newId);
context.getIdMap().put(oldId, newId);
}
String composedId = composedObject.getId();
String composedLid = composedObject.getLid();
String composedIdNew = composedId;
if (!util.isValidRegistryId(composedId)) { // Replace the id if it's not a valid ID already
composedIdNew = util.createId();
composedObject.setId(composedIdNew);
// Add entry to idMap so old composedId and refs to it are mapped to composedIdNew
context.getIdMap().put(composedId, composedIdNew);
}
if (composedLid == null || composedLid.trim().length() == 0) {
composedObject.setLid(composedIdNew);
}
// Set the parent id of this composed object to point to the new parent
bu.setParentIdForComposedObject(composedObject, idNew);
}
} catch (JAXRException e) {
throw new RegistryException(e);
} catch (JAXBException e) {
throw new RegistryException(e);
}
return roNew;
}
/** Checks if object exist in registry. */
private boolean objectExists(String id) throws RegistryException {
boolean exists = false;
try {
RegistryObjectType ro = context.getRegistryObject(id, "RegistryObject", true);
if (ro != null) {
exists = true;
}
} catch (ObjectNotFoundException e) {
// do nothing
}
return exists;
}
private String nextVersion(String lastVersion) {
if ((lastVersion == null) || (lastVersion.length() == 0)) {
lastVersion = "1.1";
}
String parts[] = lastVersion.split("\\.", 3);
int majorVersion = (new Integer(parts[0])).intValue();
int minorVersion = (new Integer(parts[1])).intValue();
// TODO: check this. What if version has more than major/minor?
if (parts.length > 2 && log.isWarnEnabled()) {
log.warn(
ServerResourceBundle.getInstance()
.getString(
"message.IgnoringVersionInfromationAfterMajorMinorVersion",
new Object[] {parts[2]}));
}
// Increment version
int newMinorVersion = minorVersion + 1;
String nextVersion = parts[0] + "." + (new Integer(newMinorVersion)).toString();
return nextVersion;
}
/*
* Loads the list of versionable RIM classes from the property file during startup.
*/
private void loadVersionableClasses() {
String versionableClassList =
RegistryProperties.getInstance()
.getProperty("omar.server.lcm.VersionManager.versionableClassList");
// System.err.println("loadVersionableClasses: versionableClassList='" + versionableClassList +
// "'");
if (versionableClassList != null) {
StringTokenizer tokenizer = new StringTokenizer(versionableClassList, "|");
while (tokenizer.hasMoreTokens()) {
try {
String versionableClassName = tokenizer.nextToken();
versionableClassName =
"org.oasis.ebxml.registry.bindings.rim." + versionableClassName + "Type";
// System.err.println(" loadVersionableClasses: versionableClassName='" +
// versionableClassName + "'");
Class versionableClass = Class.forName(versionableClassName);
versionableClassNameSet.add(versionableClass);
} catch (Exception e) {
e.printStackTrace();
}
}
} else {
// System.err.println(
// "Registry has not defined the classes that will be versioned yet. This can be done by
// setting the omar.server.lcm.VersionManager.versionableClassList property in omar.properties
// file.");
}
}
private boolean isVersionableClass(RegistryObjectType ro) {
boolean isVersionable = false;
// System.err.println("isVersionable entered. ro=" + ro.getClass().getName());
Iterator iter = versionableClassNameSet.iterator();
while (iter.hasNext()) {
Class clazz = (Class) iter.next();
// System.err.println(" isVersionable clazz=" + clazz.getName() + " isAssignableFrom = " +
// clazz.isAssignableFrom(ro.getClass()));
if (clazz.isAssignableFrom(ro.getClass())) {
isVersionable = true;
break;
}
}
return isVersionable;
}
private boolean repositoryItemsAreIdentical(RepositoryItem ri1, RepositoryItem ri2) {
DataHandler dh1 = ri1.getDataHandler();
DataHandler dh2 = ri2.getDataHandler();
return dh1.equals(dh2);
}
}