public static boolean addHandler(Registry configSystemRegistry, String payload)
throws RegistryException, XMLStreamException {
String name;
OMElement element = AXIOMUtil.stringToOM(payload);
if (element != null) {
name = element.getAttributeValue(new QName("class"));
} else return false;
if (isHandlerNameInUse(name))
throw new RegistryException("The added handler name is already in use!");
String path = getContextRoot() + name;
Resource resource;
if (!handlerExists(configSystemRegistry, name)) {
resource = new ResourceImpl();
} else {
throw new RegistryException("The added handler name is already in use!");
}
resource.setContent(payload);
try {
configSystemRegistry.beginTransaction();
configSystemRegistry.put(path, resource);
generateHandler(configSystemRegistry, path);
configSystemRegistry.commitTransaction();
} catch (Exception e) {
configSystemRegistry.rollbackTransaction();
throw new RegistryException("Unable to generate handler", e);
}
return true;
}
public static boolean updateHandler(Registry configSystemRegistry, String oldName, String payload)
throws RegistryException, XMLStreamException {
if (isHandlerNameInUse(oldName))
throw new RegistryException("Could not update handler since it is already in use!");
String newName = null;
OMElement element = AXIOMUtil.stringToOM(payload);
if (element != null) {
newName = element.getAttributeValue(new QName("class"));
}
if (newName == null || newName.equals("")) return false; // invalid configuration
if (oldName == null || oldName.equals("")) {
String path = getContextRoot() + newName;
Resource resource;
if (handlerExists(configSystemRegistry, newName)) {
return false; // we are adding a new handler
} else {
resource = new ResourceImpl();
}
resource.setContent(payload);
try {
configSystemRegistry.beginTransaction();
configSystemRegistry.put(path, resource);
generateHandler(configSystemRegistry, path);
configSystemRegistry.commitTransaction();
} catch (Exception e) {
configSystemRegistry.rollbackTransaction();
throw new RegistryException("Unable to generate handler", e);
}
return true;
}
if (newName.equals(oldName)) {
// updating the rest of the content
String oldPath = getContextRoot() + oldName;
Resource resource;
if (handlerExists(configSystemRegistry, oldName)) {
resource = configSystemRegistry.get(oldPath);
} else {
resource = new ResourceImpl(); // will this ever happen?
}
resource.setContent(payload);
try {
configSystemRegistry.beginTransaction();
removeHandler(configSystemRegistry, oldName);
configSystemRegistry.put(oldPath, resource);
generateHandler(configSystemRegistry, oldPath);
configSystemRegistry.commitTransaction();
} catch (Exception e) {
configSystemRegistry.rollbackTransaction();
throw new RegistryException("Unable to generate handler", e);
}
return true;
} else {
String oldPath = getContextRoot() + oldName;
String newPath = getContextRoot() + newName;
if (handlerExists(configSystemRegistry, newName)) {
return false; // we are trying to use the name of a existing handler
}
Resource resource;
if (handlerExists(configSystemRegistry, oldName)) {
resource = configSystemRegistry.get(oldPath);
} else {
resource = new ResourceImpl(); // will this ever happen?
}
resource.setContent(payload);
try {
configSystemRegistry.beginTransaction();
configSystemRegistry.put(newPath, resource);
generateHandler(configSystemRegistry, newPath);
removeHandler(configSystemRegistry, oldName);
configSystemRegistry.delete(oldPath);
configSystemRegistry.commitTransaction();
} catch (Exception e) {
configSystemRegistry.rollbackTransaction();
throw new RegistryException("Unable to renew handler", e);
}
return true;
}
}
public String importWADLToRegistry(
RequestContext requestContext, String commonLocation, boolean skipValidation)
throws RegistryException {
ResourcePath resourcePath = requestContext.getResourcePath();
String wadlName = RegistryUtils.getResourceName(resourcePath.getPath());
String version =
requestContext.getResource().getProperty(RegistryConstants.VERSION_PARAMETER_NAME);
if (version == null) {
version = CommonConstants.WADL_VERSION_DEFAULT_VALUE;
requestContext.getResource().setProperty(RegistryConstants.VERSION_PARAMETER_NAME, version);
}
String uri = requestContext.getSourceURL();
if (!skipValidation) {
validateWADL(uri);
}
Registry registry = requestContext.getRegistry();
Resource resource = registry.newResource();
if (resource.getUUID() == null) {
resource.setUUID(UUID.randomUUID().toString());
}
resource.setMediaType(wadlMediaType);
resource.setProperties(requestContext.getResource().getProperties());
ByteArrayOutputStream outputStream;
OMElement wadlElement;
try {
InputStream inputStream = new URL(uri).openStream();
outputStream = new ByteArrayOutputStream();
int nextChar;
while ((nextChar = inputStream.read()) != -1) {
outputStream.write(nextChar);
}
outputStream.flush();
wadlElement = AXIOMUtil.stringToOM(new String(outputStream.toByteArray()));
// to validate XML
wadlElement.toString();
} catch (Exception e) {
// This exception is unexpected because the WADL already validated
throw new RegistryException(
"Unexpected error occured " + "while reading the WADL at" + uri, e);
}
String wadlNamespace = wadlElement.getNamespace().getNamespaceURI();
String namespaceSegment =
CommonUtil.derivePathFragmentFromNamespace(wadlNamespace).replace("//", "/");
OMElement grammarsElement =
wadlElement.getFirstChildWithName(new QName(wadlNamespace, "grammars"));
String wadlBaseUri = uri.substring(0, uri.lastIndexOf("/") + 1);
if (grammarsElement != null) {
grammarsElement.detach();
wadlElement.addChild(resolveImports(grammarsElement, wadlBaseUri, version));
}
String actualPath;
if (commonLocation != null) {
actualPath = commonLocation + namespaceSegment + version + "/" + wadlName;
} else {
actualPath =
RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH
+ commonWADLLocation
+ namespaceSegment
+ version
+ "/"
+ wadlName;
}
if (resource.getProperty(CommonConstants.SOURCE_PROPERTY) == null) {
resource.setProperty(CommonConstants.SOURCE_PROPERTY, CommonConstants.SOURCE_AUTO);
}
resource.setContent(wadlElement.toString());
requestContext.setResourcePath(new ResourcePath(actualPath));
registry.put(actualPath, resource);
addImportAssociations(actualPath);
if (createService) {
OMElement serviceElement =
RESTServiceUtils.createRestServiceArtifact(
wadlElement,
wadlName,
version,
RegistryUtils.getRelativePath(requestContext.getRegistryContext(), actualPath));
String servicePath = RESTServiceUtils.addServiceToRegistry(requestContext, serviceElement);
addDependency(servicePath, actualPath);
String endpointPath = createEndpointElement(requestContext, wadlElement, version);
if (endpointPath != null) {
addDependency(servicePath, endpointPath);
}
}
return actualPath;
}