public void testRootLevelVersioning() throws Exception {
Resource r1 = registry.newResource();
r1.setContent("r1c1");
registry.put("/vtr1", r1);
registry.createVersion("/");
Collection c2 = registry.newCollection();
registry.put("/vtc2", c2);
registry.createVersion("/");
String[] rootVersions = registry.getVersions("/");
Collection rootv0 = (Collection) registry.get(rootVersions[0]);
String[] rootv0Children = (String[]) rootv0.getContent();
assertTrue(
"Root should have child vtr1", RegistryUtils.containsAsSubString("/vtr1", rootv0Children));
assertTrue(
"Root should have child vtc2", RegistryUtils.containsAsSubString("/vtc2", rootv0Children));
Collection rootv1 = (Collection) registry.get(rootVersions[1]);
String[] rootv1Children = (String[]) rootv1.getContent();
assertTrue(
"Root should have child vtr1", RegistryUtils.containsAsSubString("/vtr1", rootv1Children));
assertFalse(
"Root should not have child vtc2",
RegistryUtils.containsAsSubString("/vtc2", rootv1Children));
}
private Map<String, Map<String, ServiceBean>> buildServiceVersionHierarchy(
ServiceBean[] serviceBeans) {
Map<String, Map<String, ServiceBean>> hierarchy =
new LinkedHashMap<String, Map<String, ServiceBean>>();
if (serviceBeans == null) {
return hierarchy;
}
for (ServiceBean serviceBean : serviceBeans) {
if (serviceBean != null) {
String path = RegistryUtils.getParentPath(serviceBean.getPath());
String version = RegistryUtils.getResourceName(path);
if (!version.replace("-SNAPSHOT", "").matches("^\\d+[.]\\d+[.]\\d+$")) {
version = "SNAPSHOT";
serviceBean.setPath(serviceBean.getPath());
} else {
serviceBean.setPath(RegistryUtils.getParentPath(path));
}
Map<String, ServiceBean> versionMap;
if (hierarchy.containsKey(serviceBean.getQName())) {
versionMap = hierarchy.get(serviceBean.getQName());
} else {
versionMap = new LinkedHashMap<String, ServiceBean>();
hierarchy.put(serviceBean.getQName(), versionMap);
}
versionMap.put(version, serviceBean);
}
}
return hierarchy;
}
public static boolean generateHandler(Registry configSystemRegistry, String resourceFullPath)
throws RegistryException, XMLStreamException {
RegistryContext registryContext = configSystemRegistry.getRegistryContext();
if (registryContext == null) {
return false;
}
Resource resource = configSystemRegistry.get(resourceFullPath);
if (resource != null) {
String content = null;
if (resource.getContent() != null) {
content = RegistryUtils.decodeBytes((byte[]) resource.getContent());
}
if (content != null) {
OMElement handler = AXIOMUtil.stringToOM(content);
if (handler != null) {
OMElement dummy = OMAbstractFactory.getOMFactory().createOMElement("dummy", null);
dummy.addChild(handler);
try {
configSystemRegistry.beginTransaction();
boolean status =
RegistryConfigurationProcessor.updateHandler(
dummy,
configSystemRegistry.getRegistryContext(),
HandlerLifecycleManager.USER_DEFINED_HANDLER_PHASE);
configSystemRegistry.commitTransaction();
return status;
} catch (Exception e) {
configSystemRegistry.rollbackTransaction();
throw new RegistryException("Unable to add handler", e);
}
}
}
}
return false;
}
public static int[] getAdjacentVersions(
ServletConfig config, HttpSession session, String path, int current) throws Exception {
String[] nodes =
Utils.getSortedChildNodes(
new ResourceServiceClient(config, session).getCollectionContent(path));
int[] versions = new int[2];
versions[0] = -1;
versions[1] = -1;
int previous = -1;
for (String node : nodes) {
String name = RegistryUtils.getResourceName(node);
try {
int temp = Integer.parseInt(name);
if (previous == current) {
// The last match was the current version. Therefore, the match is the version
// after the current.
versions[1] = temp;
break;
}
if (temp == current) {
// The match is the current version. Therefore, the last match was the version
// before the current.
versions[0] = previous;
}
previous = temp;
} catch (NumberFormatException ignore) {
}
}
return versions;
}
/**
* Configures the swagger resource path form its content and returns the swagger document path.
*
* @param rootLocation root location of the swagger files.
* @param content swagger content.
* @return Common resource path.
*/
private String getSwaggerDocumentPath(String rootLocation, JsonObject content)
throws RegistryException {
String swaggerDocPath = requestContext.getResourcePath().getPath();
String swaggerDocName =
swaggerDocPath.substring(swaggerDocPath.lastIndexOf(RegistryConstants.PATH_SEPARATOR) + 1);
JsonElement infoElement = content.get(SwaggerConstants.INFO);
JsonObject infoObject = (infoElement != null) ? infoElement.getAsJsonObject() : null;
if (infoObject == null || infoElement.isJsonNull()) {
throw new RegistryException("Invalid swagger document.");
}
String serviceName = infoObject.get(SwaggerConstants.TITLE).getAsString().replaceAll("\\s", "");
String serviceProvider = CarbonContext.getThreadLocalCarbonContext().getUsername();
swaggerResourcesPath =
rootLocation
+ serviceProvider
+ RegistryConstants.PATH_SEPARATOR
+ serviceName
+ RegistryConstants.PATH_SEPARATOR
+ documentVersion;
String pathExpression = getSwaggerRegistryPath(swaggerDocName, serviceProvider);
return RegistryUtils.getAbsolutePath(registry.getRegistryContext(), pathExpression);
}
/**
* Saves a swagger document in the registry.
*
* @param contentStream resource content.
* @param path resource path.
* @param documentVersion version of the swagger document.
* @throws RegistryException If fails to add the swagger document to registry.
*/
private boolean addSwaggerDocumentToRegistry(
ByteArrayOutputStream contentStream, String path, String documentVersion)
throws RegistryException {
Resource resource;
/*
Checks if a resource is already exists in the given path.
If exists,
Compare resource contents and if updated, updates the document, if not skip the updating process
If not exists,
Creates a new resource and add to the resource path.
*/
if (registry.resourceExists(path)) {
resource = registry.get(path);
Object resourceContentObj = resource.getContent();
String resourceContent;
if (resourceContentObj instanceof String) {
resourceContent = (String) resourceContentObj;
resource.setContent(RegistryUtils.encodeString(resourceContent));
} else if (resourceContentObj instanceof byte[]) {
resourceContent = RegistryUtils.decodeBytes((byte[]) resourceContentObj);
} else {
throw new RegistryException(CommonConstants.INVALID_CONTENT);
}
if (resourceContent.equals(contentStream.toString())) {
log.info("Old content is same as the new content. Skipping the put action.");
return false;
}
} else {
// If a resource does not exist in the given path.
resource = new ResourceImpl();
}
String resourceId =
(resource.getUUID() == null) ? UUID.randomUUID().toString() : resource.getUUID();
resource.setUUID(resourceId);
resource.setMediaType(CommonConstants.SWAGGER_MEDIA_TYPE);
resource.setContent(contentStream.toByteArray());
resource.addProperty(RegistryConstants.VERSION_PARAMETER_NAME, documentVersion);
CommonUtil.copyProperties(this.requestContext.getResource(), resource);
registry.put(path, resource);
return true;
}
public static String getHandlerConfiguration(Registry configSystemRegistry, String name)
throws RegistryException, XMLStreamException {
String path = getContextRoot() + name;
Resource resource;
if (handlerExists(configSystemRegistry, name)) {
resource = configSystemRegistry.get(path);
return RegistryUtils.decodeBytes((byte[]) resource.getContent());
}
return null;
}
/**
* Generate REST service path
*
* @param requestContext Request Context
* @param data REST Service content(OMElement)
* @param serviceName REST Service name
* @param serviceProvider Service Provider(current user)
* @return Populated Path
*/
private static String getRestServicePath(
RequestContext requestContext, OMElement data, String serviceName, String serviceProvider) {
String pathExpression =
Utils.getRxtService().getStoragePath(CommonConstants.REST_SERVICE_MEDIA_TYPE);
pathExpression = CommonUtil.replaceExpressionOfPath(pathExpression, "name", serviceName);
pathExpression =
RegistryUtils.getAbsolutePath(
requestContext.getRegistryContext(),
CommonUtil.getPathFromPathExpression(
pathExpression, data, requestContext.getResource().getProperties()));
pathExpression =
CommonUtil.getPathFromPathExpression(
pathExpression, requestContext.getResource().getProperties(), null);
pathExpression =
RegistryUtils.getAbsolutePath(
requestContext.getRegistryContext(),
CommonUtil.replaceExpressionOfPath(pathExpression, "provider", serviceProvider));
return CommonUtil.getRegistryPath(
requestContext.getRegistry().getRegistryContext(), pathExpression);
}
/**
* Adds swagger 1.2 api resource documents to registry and returns a list of resource documents as
* JSON objects.
*
* @param swaggerDocObject swagger document JSON object.
* @param sourceUrl source url of the swagger document.
* @param swaggerDocPath swagger document path. (path of the registry)
* @return List of api resources.
* @throws RegistryException If fails to import or save resource docs to the registry.
*/
private List<JsonObject> addResourceDocsToRegistry(
JsonObject swaggerDocObject, String sourceUrl, String swaggerDocPath)
throws RegistryException {
if (sourceUrl == null) {
log.debug(CommonConstants.EMPTY_URL);
log.warn("Resource paths cannot be read. Creating the REST service might fail.");
return null;
} else if (sourceUrl.startsWith("file")) {
sourceUrl = sourceUrl.substring(0, sourceUrl.lastIndexOf("/"));
}
List<JsonObject> resourceObjects = new ArrayList<>();
// Adding Resource documents to registry.
JsonArray pathResources = swaggerDocObject.get(SwaggerConstants.APIS).getAsJsonArray();
ByteArrayOutputStream resourceContentStream = null;
InputStream resourceInputStream = null;
String path;
/*
Loops through apis array of the swagger 1.2 api-doc and reads all the resource documents and saves them in to
the registry.
*/
for (JsonElement pathResource : pathResources) {
JsonObject resourceObj = pathResource.getAsJsonObject();
path = resourceObj.get(SwaggerConstants.PATH).getAsString();
try {
resourceInputStream = new URL(sourceUrl + path).openStream();
} catch (IOException e) {
throw new RegistryException("The URL " + sourceUrl + path + " is incorrect.", e);
}
resourceContentStream = CommonUtil.readSourceContent(resourceInputStream);
JsonObject resourceObject = parser.parse(resourceContentStream.toString()).getAsJsonObject();
resourceObjects.add(resourceObject);
if (endpointElement == null) {
createEndpointElement(resourceObject, SwaggerConstants.SWAGGER_VERSION_12);
}
// path = swaggerResourcesPath + path;
path = path.replace("/", "");
path = CommonUtil.replaceExpressionOfPath(swaggerResourcesPath, "name", path);
path = RegistryUtils.getAbsolutePath(registry.getRegistryContext(), path);
// Save Resource document to registry
if (addSwaggerDocumentToRegistry(resourceContentStream, path, documentVersion)) {
// Adding an dependency to API_DOC
registry.addAssociation(swaggerDocPath, path, CommonConstants.DEPENDS);
}
}
CommonUtil.closeOutputStream(resourceContentStream);
CommonUtil.closeInputStream(resourceInputStream);
return resourceObjects;
}
public static String getGreatestChildVersion(
ServletConfig config, HttpSession session, String path) throws Exception {
String[] nodes =
Utils.getSortedChildNodes(
new ResourceServiceClient(config, session).getCollectionContent(path));
String last = "";
for (String node : nodes) {
String name = RegistryUtils.getResourceName(node);
try {
Integer.parseInt(name);
last = name;
} catch (NumberFormatException ignore) {
}
}
return last;
}
/**
* Adds the service endpoint element to the registry.
*
* @param requestContext current request information.
* @param endpointElement endpoint metadata element.
* @param endpointPath endpoint location.
* @return The resource path of the endpoint.
* @throws RegistryException If fails to add the endpoint to the registry.
*/
public static String addEndpointToRegistry(
RequestContext requestContext, OMElement endpointElement, String endpointPath)
throws RegistryException {
if (requestContext == null || endpointElement == null || endpointPath == null) {
throw new IllegalArgumentException(
"Some or all of the arguments may be null. Cannot add the endpoint to registry. ");
}
endpointPath = getEndpointPath(requestContext, endpointElement, endpointPath);
Registry registry = requestContext.getRegistry();
// Creating new resource.
Resource endpointResource = new ResourceImpl();
// setting endpoint media type.
endpointResource.setMediaType(CommonConstants.ENDPOINT_MEDIA_TYPE);
// set content.
endpointResource.setContent(RegistryUtils.encodeString(endpointElement.toString()));
// copy other property
endpointResource.setProperties(copyProperties(requestContext));
// set path
// endpointPath = getChrootedEndpointLocation(requestContext.getRegistryContext()) +
// endpointPath;
String resourceId = endpointResource.getUUID();
// set resource UUID
resourceId = (resourceId == null) ? UUID.randomUUID().toString() : resourceId;
endpointResource.setUUID(resourceId);
// saving the api resource to repository.
registry.put(endpointPath, endpointResource);
if (log.isDebugEnabled()) {
log.debug("Endpoint created at " + endpointPath);
}
return endpointPath;
}
public static void buildMenuItems(HttpServletRequest request, String s, String s1, String s2) {
int menuOrder = 50;
if (CarbonUIUtil.isUserAuthorized(request, "/permission/admin/manage/resources/ws-api")) {
HttpSession session = request.getSession();
String cookie = (String) session.getAttribute(ServerConstants.ADMIN_SERVICE_COOKIE);
try {
WSRegistryServiceClient registry = new WSRegistryServiceClient(s2, cookie);
List<GovernanceArtifactConfiguration> configurations =
GovernanceUtils.findGovernanceArtifactConfigurations(registry);
Map<String, String> customAddUIMap = new LinkedHashMap<String, String>();
Map<String, String> customViewUIMap = new LinkedHashMap<String, String>();
List<Menu> userCustomMenuItemsList = new LinkedList<Menu>();
for (GovernanceArtifactConfiguration configuration : configurations) {
Component component = new Component();
OMElement uiConfigurations = configuration.getUIConfigurations();
String key = configuration.getKey();
String configurationPath =
RegistryConstants.CONFIG_REGISTRY_BASE_PATH
+ RegistryConstants.GOVERNANCE_COMPONENT_PATH
+ "/configuration/";
String layoutStoragePath = configurationPath + key;
RealmService realmService = registry.getRegistryContext().getRealmService();
if (realmService
.getTenantUserRealm(realmService.getTenantManager().getTenantId(s1))
.getAuthorizationManager()
.isUserAuthorized(s, configurationPath, ActionConstants.PUT)
|| registry.resourceExists(layoutStoragePath)) {
List<Menu> menuList = component.getMenusList();
if (uiConfigurations != null) {
ComponentBuilder.processMenus("artifactType", uiConfigurations, component);
ComponentBuilder.processCustomUIs(uiConfigurations, component);
}
if (menuList.size() == 0) {
// if no menu definitions were present, define the default ones.
menuOrder = buildMenuList(request, configuration, menuList, key, menuOrder);
}
userCustomMenuItemsList.addAll(menuList);
customAddUIMap.putAll(component.getCustomAddUIMap());
Map<String, String> viewUIMap = component.getCustomViewUIMap();
if (viewUIMap.isEmpty()) {
// if no custom UI definitions were present, define the default.
buildViewUI(configuration, viewUIMap, key);
}
customViewUIMap.putAll(viewUIMap);
OMElement layout = configuration.getContentDefinition();
if (layout != null && !registry.resourceExists(layoutStoragePath)) {
Resource resource = registry.newResource();
resource.setContent(RegistryUtils.encodeString(layout.toString()));
resource.setMediaType("application/xml");
registry.put(layoutStoragePath, resource);
}
}
}
session.setAttribute(
MenuAdminClient.USER_CUSTOM_MENU_ITEMS,
userCustomMenuItemsList.toArray(new Menu[userCustomMenuItemsList.size()]));
session.setAttribute("customAddUI", customAddUIMap);
session.setAttribute("customViewUI", customViewUIMap);
} catch (RegistryException e) {
log.error("unable to create connection to registry");
} catch (org.wso2.carbon.user.api.UserStoreException e) {
log.error("unable to realm service");
}
}
}
private String getChrootedSchemaLocation(RegistryContext registryContext) {
return RegistryUtils.getAbsolutePath(
registryContext,
RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH + getCommonSchemaLocation());
}
public static String decorateVersionElement(
String version,
String basicVersionElement,
String path,
String type,
String append,
String screenWidth,
ServletConfig config,
HttpSession session,
HttpServletRequest request) {
String hrefPrefix = "../resources/resource.jsp?region=region3&item=resource_browser_menu&path=";
String hrefPostfix = (screenWidth != null) ? "&screenWidth=" + screenWidth : "";
String patchPath = RegistryUtils.getParentPath(path);
String minorPath = RegistryUtils.getParentPath(patchPath);
String majorPath = RegistryUtils.getParentPath(minorPath);
String servicePath = RegistryUtils.getParentPath(majorPath);
String versions[] = version.split("[.]");
StringBuffer sb = new StringBuffer("$1type=\"hidden\"$2");
if (type.equals("collection")) {
sb.append("<a href=\"")
.append(hrefPrefix)
.append(majorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("\">")
.append(versions[0])
.append("</a>");
sb.append(".");
sb.append("<a href=\"")
.append(hrefPrefix)
.append(minorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("\">")
.append(versions[1])
.append("</a>");
sb.append(".");
sb.append("<a href=\"")
.append(hrefPrefix)
.append(patchPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("\">")
.append(versions[2])
.append("</a>");
sb.append(append);
} else if (type.equals("patch")) {
sb.append("<a href=\"")
.append(hrefPrefix)
.append(majorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("\">")
.append(versions[0])
.append("</a>");
sb.append(".");
sb.append("<a href=\"")
.append(hrefPrefix)
.append(minorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("\">")
.append(versions[1])
.append("</a>");
sb.append(".");
sb.append("<a href=\"javascript:void(0)\">").append(versions[2]).append("</a>");
sb.append(append);
try {
int[] adjacentVersions =
getAdjacentVersions(config, session, minorPath, Integer.parseInt(versions[2]));
sb.append(" ");
if (adjacentVersions[0] > -1) {
sb.append("<a class=\"icon-link\" style=\"background-image: ")
.append("url(../resources/images/arrow-up.gif);float:none !important;")
.append("margin-bottom:0px !important;margin-top:0px !important;")
.append("margin-left:0px !important\" href=\"")
.append(hrefPrefix)
.append(minorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("/")
.append(adjacentVersions[0])
.append("\" title=\"")
.append(
CarbonUIUtil.geti18nString(
"previous.version",
"org.wso2.carbon.governance.generic.ui.i18n.Resources",
request.getLocale()))
.append(": ")
.append(versions[0])
.append(".")
.append(versions[1])
.append(".")
.append(adjacentVersions[0])
.append("\"/>");
}
if (adjacentVersions[1] > -1) {
sb.append("<a class=\"icon-link\" style=\"background-image: ")
.append("url(../resources/images/arrow-right.gif);float:none !important;")
.append("margin-bottom:0px !important;margin-top:0px !important;")
.append("margin-left:0px !important\" href=\"")
.append(hrefPrefix)
.append(minorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("/")
.append(adjacentVersions[1])
.append("\" title=\"")
.append(
CarbonUIUtil.geti18nString(
"next.version",
"org.wso2.carbon.governance.generic.ui.i18n.Resources",
request.getLocale()))
.append(": ")
.append(versions[0])
.append(".")
.append(versions[1])
.append(".")
.append(adjacentVersions[1])
.append("\"/>");
}
} catch (Exception ignore) {
}
} else if (type.equals("minor")) {
sb.append("<a href=\"")
.append(hrefPrefix)
.append(majorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("\">")
.append(versions[0])
.append("</a>");
sb.append(".");
sb.append("<a href=\"javascript:void(0)\">").append(versions[1]).append("</a>");
sb.append(".");
sb.append("<a href=\"")
.append(hrefPrefix)
.append(patchPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("\">")
.append(versions[2])
.append("</a>");
sb.append(append);
try {
int[] adjacentVersions =
getAdjacentVersions(config, session, majorPath, Integer.parseInt(versions[1]));
sb.append(" ");
if (adjacentVersions[0] > -1) {
String latestPatch =
getGreatestChildVersion(config, session, majorPath + "/" + adjacentVersions[0]);
sb.append("<a class=\"icon-link\" style=\"background-image: ")
.append("url(../resources/images/arrow-up.gif);float:none !important;")
.append("margin-bottom:0px !important;margin-top:0px !important;")
.append("margin-left:0px !important\" href=\"")
.append(hrefPrefix)
.append(majorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("/")
.append(adjacentVersions[0])
.append("\" title=\"")
.append(
CarbonUIUtil.geti18nString(
"previous.version",
"org.wso2.carbon.governance.generic.ui.i18n.Resources",
request.getLocale()))
.append(": ")
.append(versions[0])
.append(".")
.append(adjacentVersions[0])
.append(".")
.append(latestPatch)
.append("\"/>");
}
if (adjacentVersions[1] > -1) {
String latestPatch =
getGreatestChildVersion(config, session, majorPath + "/" + adjacentVersions[1]);
sb.append("<a class=\"icon-link\" style=\"background-image: ")
.append("url(../resources/images/arrow-right.gif);float:none !important;")
.append("margin-bottom:0px !important;margin-top:0px !important;")
.append("margin-left:0px !important\" href=\"")
.append(hrefPrefix)
.append(majorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("/")
.append(adjacentVersions[1])
.append("\" title=\"")
.append(
CarbonUIUtil.geti18nString(
"next.version",
"org.wso2.carbon.governance.generic.ui.i18n.Resources",
request.getLocale()))
.append(": ")
.append(versions[0])
.append(".")
.append(adjacentVersions[1])
.append(".")
.append(latestPatch)
.append("\"/>");
}
} catch (Exception ignore) {
}
} else if (type.equals("major")) {
sb.append("<a href=\"javascript:void(0)\">").append(versions[0]).append("</a>");
sb.append(".");
sb.append("<a href=\"")
.append(hrefPrefix)
.append(minorPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("\">")
.append(versions[1])
.append("</a>");
sb.append(".");
sb.append("<a href=\"")
.append(hrefPrefix)
.append(patchPath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("\">")
.append(versions[2])
.append("</a>");
sb.append(append);
try {
int[] adjacentVersions =
getAdjacentVersions(config, session, servicePath, Integer.parseInt(versions[0]));
sb.append(" ");
if (adjacentVersions[0] > -1) {
String latestMinor =
getGreatestChildVersion(config, session, servicePath + "/" + adjacentVersions[0]);
String latestPatch =
getGreatestChildVersion(
config, session, servicePath + "/" + adjacentVersions[0] + "/" + latestMinor);
sb.append("<a class=\"icon-link\" style=\"background-image: ")
.append("url(../resources/images/arrow-up.gif);float:none !important;")
.append("margin-bottom:0px !important;margin-top:0px !important;")
.append("margin-left:0px !important\" href=\"")
.append(hrefPrefix)
.append(servicePath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("/")
.append(adjacentVersions[0])
.append("\" title=\"")
.append(
CarbonUIUtil.geti18nString(
"previous.version",
"org.wso2.carbon.governance.generic.ui.i18n.Resources",
request.getLocale()))
.append(": ")
.append(adjacentVersions[0])
.append(".")
.append(latestMinor)
.append(".")
.append(latestPatch)
.append("\"/>");
}
if (adjacentVersions[1] > -1) {
String latestMinor =
getGreatestChildVersion(config, session, servicePath + "/" + adjacentVersions[1]);
String latestPatch =
getGreatestChildVersion(
config, session, servicePath + "/" + adjacentVersions[1] + "/" + latestMinor);
sb.append("<a class=\"icon-link\" style=\"background-image: ")
.append("url(../resources/images/arrow-right.gif);float:none !important;")
.append("margin-bottom:0px !important;margin-top:0px !important;")
.append("margin-left:0px !important\" href=\"")
.append(hrefPrefix)
.append(servicePath.replaceAll("&", "%26"))
.append(hrefPostfix)
.append("/")
.append(adjacentVersions[1])
.append("\" title=\"")
.append(
CarbonUIUtil.geti18nString(
"next.version",
"org.wso2.carbon.governance.generic.ui.i18n.Resources",
request.getLocale()))
.append(": ")
.append(adjacentVersions[1])
.append(".")
.append(latestMinor)
.append(".")
.append(latestPatch)
.append("\"/>");
}
} catch (Exception ignore) {
}
}
return basicVersionElement.replaceAll(
"(<input[^>]*)type=\"text\"([^>]*id=\"id_Overview_Version\"[^>]*>)", sb.toString());
}
/**
* Saves the REST Service registry artifact created from the imported swagger definition.
*
* @param requestContext information about current request.
* @param data service artifact metadata.
* @throws RegistryException If a failure occurs when adding the api to registry.
*/
public static String addServiceToRegistry(RequestContext requestContext, OMElement data)
throws RegistryException {
if (requestContext == null || data == null) {
throw new IllegalArgumentException(
"Some or all of the arguments may be null. Cannot add the rest service to registry. ");
}
Registry registry = requestContext.getRegistry();
// Creating new resource.
Resource serviceResource = new ResourceImpl();
// setting API media type.
serviceResource.setMediaType(CommonConstants.REST_SERVICE_MEDIA_TYPE);
serviceResource.setProperty(CommonConstants.SOURCE_PROPERTY, CommonConstants.SOURCE_AUTO);
OMElement overview =
data.getFirstChildWithName(new QName(CommonConstants.SERVICE_ELEMENT_NAMESPACE, OVERVIEW));
String serviceVersion =
overview
.getFirstChildWithName(new QName(CommonConstants.SERVICE_ELEMENT_NAMESPACE, VERSION))
.getText();
String apiName =
overview
.getFirstChildWithName(new QName(CommonConstants.SERVICE_ELEMENT_NAMESPACE, NAME))
.getText();
serviceVersion =
(serviceVersion == null) ? CommonConstants.SERVICE_VERSION_DEFAULT_VALUE : serviceVersion;
String serviceProvider = CarbonContext.getThreadLocalCarbonContext().getUsername();
String pathExpression = getRestServicePath(requestContext, data, apiName, serviceProvider);
// set version property.
serviceResource.setProperty(RegistryConstants.VERSION_PARAMETER_NAME, serviceVersion);
// copy other property
serviceResource.setProperties(copyProperties(requestContext));
// set content.
serviceResource.setContent(RegistryUtils.encodeString(data.toString()));
String resourceId = serviceResource.getUUID();
// set resource UUID
resourceId = (resourceId == null) ? UUID.randomUUID().toString() : resourceId;
serviceResource.setUUID(resourceId);
String servicePath =
getChrootedServiceLocation(requestContext.getRegistryContext())
+ CarbonContext.getThreadLocalCarbonContext().getUsername()
+ RegistryConstants.PATH_SEPARATOR
+ apiName
+ RegistryConstants.PATH_SEPARATOR
+ serviceVersion
+ RegistryConstants.PATH_SEPARATOR
+ apiName
+ "-rest_service";
// saving the api resource to repository.
registry.put(pathExpression, serviceResource);
String defaultLifeCycle = CommonUtil.getDefaultLifecycle(registry, "restservice");
if (defaultLifeCycle != null && !defaultLifeCycle.isEmpty()) {
registry.associateAspect(serviceResource.getId(), defaultLifeCycle);
}
if (log.isDebugEnabled()) {
log.debug("REST Service created at " + pathExpression);
}
return pathExpression;
}
public void put(RequestContext requestContext) throws RegistryException {
WSDLProcessor wsdl = null;
if (!CommonUtil.isUpdateLockAvailable()) {
return;
}
CommonUtil.acquireUpdateLock();
try {
Registry registry = requestContext.getRegistry();
Resource resource = requestContext.getResource();
if (resource == null) {
throw new RegistryException("The resource is not available.");
}
String originalServicePath = requestContext.getResourcePath().getPath();
String resourceName = RegistryUtils.getResourceName(originalServicePath);
OMElement serviceInfoElement, previousServiceInfoElement = null;
Object resourceContent = resource.getContent();
String serviceInfo;
if (resourceContent instanceof String) {
serviceInfo = (String) resourceContent;
} else {
serviceInfo = RegistryUtils.decodeBytes((byte[]) resourceContent);
}
try {
XMLStreamReader reader =
XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(serviceInfo));
StAXOMBuilder builder = new StAXOMBuilder(reader);
serviceInfoElement = builder.getDocumentElement();
} catch (Exception e) {
String msg =
"Error in parsing the service content of the service. "
+ "The requested path to store the service: "
+ originalServicePath
+ ".";
log.error(msg);
throw new RegistryException(msg, e);
}
// derive the service path that the service should be saved.
String serviceName = CommonUtil.getServiceName(serviceInfoElement);
String serviceNamespace = CommonUtil.getServiceNamespace(serviceInfoElement);
String servicePath = "";
if (serviceInfoElement.getChildrenWithLocalName("newServicePath").hasNext()) {
Iterator OmElementIterator = serviceInfoElement.getChildrenWithLocalName("newServicePath");
while (OmElementIterator.hasNext()) {
OMElement next = (OMElement) OmElementIterator.next();
servicePath = next.getText();
break;
}
} else {
if (registry.resourceExists(originalServicePath)) {
// Fixing REGISTRY-1790. Save the Service to the given original
// service path if there is a service already exists there
servicePath = originalServicePath;
} else {
servicePath =
RegistryUtils.getAbsolutePath(
registry.getRegistryContext(),
registry.getRegistryContext().getServicePath()
+ (serviceNamespace == null
? ""
: CommonUtil.derivePathFragmentFromNamespace(serviceNamespace))
+ serviceName);
}
}
String serviceVersion =
org.wso2.carbon.registry.common.utils.CommonUtil.getServiceVersion(serviceInfoElement);
if (serviceVersion.length() == 0) {
serviceVersion = defaultServiceVersion;
CommonUtil.setServiceVersion(serviceInfoElement, serviceVersion);
resource.setContent(serviceInfoElement.toString());
}
// saving the artifact id.
String serviceId = resource.getUUID();
if (serviceId == null) {
// generate a service id
serviceId = UUID.randomUUID().toString();
resource.setUUID(serviceId);
}
if (registry.resourceExists(servicePath)) {
Resource oldResource = registry.get(servicePath);
String oldContent;
Object content = oldResource.getContent();
if (content instanceof String) {
oldContent = (String) content;
} else {
oldContent = RegistryUtils.decodeBytes((byte[]) content);
}
OMElement oldServiceInfoElement = null;
if (serviceInfo.equals(oldContent)) {
// TODO: This needs a better solution. This fix was put in place to avoid
// duplication of services under /_system/governance, when no changes were made.
// However, the fix is not perfect and needs to be rethought. Perhaps the logic
// below can be reshaped a bit, or may be we don't need to compare the
// difference over here with a little fix to the Governance API end. - Janaka.
// We have fixed this assuming that the temp path where services are stored is under
// /_system/governance/[serviceName]
// Hence if we are to change that location, then we need to change the following code
// segment as well
String tempPath =
RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH
+ RegistryConstants.PATH_SEPARATOR
+ resourceName;
if (!originalServicePath.equals(tempPath)) {
String path =
RegistryUtils.getRelativePathToOriginal(
servicePath, RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH);
ArtifactManager.getArtifactManager().getTenantArtifactRepository().addArtifact(path);
return;
}
requestContext.setProcessingComplete(true);
return;
}
if ("true".equals(resource.getProperty("registry.DefinitionImport"))) {
resource.removeProperty("registry.DefinitionImport");
try {
XMLStreamReader reader =
XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(oldContent));
StAXOMBuilder builder = new StAXOMBuilder(reader);
oldServiceInfoElement = builder.getDocumentElement();
CommonUtil.setServiceName(
oldServiceInfoElement, CommonUtil.getServiceName(serviceInfoElement));
CommonUtil.setServiceNamespace(
oldServiceInfoElement, CommonUtil.getServiceNamespace(serviceInfoElement));
CommonUtil.setDefinitionURL(
oldServiceInfoElement, CommonUtil.getDefinitionURL(serviceInfoElement));
CommonUtil.setEndpointEntries(
oldServiceInfoElement, CommonUtil.getEndpointEntries(serviceInfoElement));
CommonUtil.setServiceVersion(
oldServiceInfoElement,
org.wso2.carbon.registry.common.utils.CommonUtil.getServiceVersion(
serviceInfoElement));
serviceInfoElement = oldServiceInfoElement;
resource.setContent(serviceInfoElement.toString());
resource.setDescription(oldResource.getDescription());
} catch (Exception e) {
String msg =
"Error in parsing the service content of the service. "
+ "The requested path to store the service: "
+ originalServicePath
+ ".";
log.error(msg);
throw new RegistryException(msg, e);
}
}
try {
previousServiceInfoElement = AXIOMUtil.stringToOM(oldContent);
} catch (XMLStreamException e) {
String msg =
"Error in parsing the service content of the service. "
+ "The requested path to store the service: "
+ originalServicePath
+ ".";
log.error(msg);
throw new RegistryException(msg, e);
}
} else if ("true".equals(resource.getProperty("registry.DefinitionImport"))) {
resource.removeProperty("registry.DefinitionImport");
}
// CommonUtil.addGovernanceArtifactEntryWithAbsoluteValues(
// CommonUtil.getUnchrootedSystemRegistry(requestContext),
// serviceId, servicePath);
String definitionURL = CommonUtil.getDefinitionURL(serviceInfoElement);
if (previousServiceInfoElement != null) {
String oldDefinition = CommonUtil.getDefinitionURL(previousServiceInfoElement);
if ((!"".equals(oldDefinition) && "".equals(definitionURL))
|| (!"".endsWith(oldDefinition) && !oldDefinition.equals(definitionURL))) {
try {
registry.removeAssociation(servicePath, oldDefinition, CommonConstants.DEPENDS);
registry.removeAssociation(oldDefinition, servicePath, CommonConstants.USED_BY);
EndpointUtils.removeEndpointEntry(oldDefinition, serviceInfoElement, registry);
resource.setContent(
RegistryUtils.decodeBytes((serviceInfoElement.toString()).getBytes()));
} catch (RegistryException e) {
throw new RegistryException(
"Failed to remove endpoints from Service UI : " + serviceName, e);
}
}
}
boolean alreadyAdded = false;
if (definitionURL != null
&& (definitionURL.startsWith("http://") || definitionURL.startsWith("https://"))) {
String definitionPath;
if (definitionURL.toLowerCase().endsWith("wsdl")) {
wsdl = buildWSDLProcessor(requestContext);
RequestContext context =
new RequestContext(
registry, requestContext.getRepository(), requestContext.getVersionRepository());
context.setResourcePath(
new ResourcePath(RegistryConstants.PATH_SEPARATOR + serviceName + ".wsdl"));
context.setSourceURL(definitionURL);
context.setResource(new ResourceImpl());
definitionPath =
wsdl.addWSDLToRegistry(
context,
definitionURL,
null,
false,
false,
disableWSDLValidation,
disableSymlinkCreation);
} else if (definitionURL.toLowerCase().endsWith("wadl")) {
WADLProcessor wadlProcessor = buildWADLProcessor(requestContext);
wadlProcessor.setCreateService(false);
RequestContext context =
new RequestContext(
registry, requestContext.getRepository(), requestContext.getVersionRepository());
context.setResourcePath(
new ResourcePath(RegistryConstants.PATH_SEPARATOR + serviceName + ".wadl"));
context.setSourceURL(definitionURL);
context.setResource(new ResourceImpl());
definitionPath = wadlProcessor.importWADLToRegistry(context, null, disableWADLValidation);
} else {
throw new RegistryException(
"Invalid service definition found. " + "Please enter a valid WSDL/WADL URL");
}
if (definitionPath == null) {
return;
}
definitionURL =
RegistryUtils.getRelativePath(requestContext.getRegistryContext(), definitionPath);
CommonUtil.setDefinitionURL(serviceInfoElement, definitionURL);
resource.setContent(RegistryUtils.decodeBytes((serviceInfoElement.toString()).getBytes()));
// updating the wsdl/wadl url
((ResourceImpl) resource).prepareContentForPut();
persistServiceResource(registry, resource, servicePath);
alreadyAdded = true;
// and make the associations
registry.addAssociation(servicePath, definitionPath, CommonConstants.DEPENDS);
registry.addAssociation(definitionPath, servicePath, CommonConstants.USED_BY);
} else if (definitionURL != null && definitionURL.startsWith(RegistryConstants.ROOT_PATH)) {
// it seems definitionUrl is a registry path..
String definitionPath =
RegistryUtils.getAbsolutePath(requestContext.getRegistryContext(), definitionURL);
if (!definitionPath.startsWith(
RegistryUtils.getAbsolutePath(
requestContext.getRegistryContext(),
RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH))) {
definitionPath = RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH + definitionPath;
}
boolean addItHere = false;
if (!registry.resourceExists(definitionPath)) {
String msg =
"Associating service to a non-existing WSDL. wsdl url: "
+ definitionPath
+ ", "
+ "service path: "
+ servicePath
+ ".";
log.error(msg);
throw new RegistryException(msg);
}
if (!registry.resourceExists(servicePath)) {
addItHere = true;
} else {
Association[] dependencies =
registry.getAssociations(servicePath, CommonConstants.DEPENDS);
boolean dependencyFound = false;
if (dependencies != null) {
for (Association dependency : dependencies) {
if (definitionPath.equals(dependency.getDestinationPath())) {
dependencyFound = true;
}
}
}
if (!dependencyFound) {
addItHere = true;
}
}
if (addItHere) { // add the service right here..
((ResourceImpl) resource).prepareContentForPut();
persistServiceResource(registry, resource, servicePath);
alreadyAdded = true;
// and make the associations
registry.addAssociation(servicePath, definitionPath, CommonConstants.DEPENDS);
registry.addAssociation(definitionPath, servicePath, CommonConstants.USED_BY);
}
}
if (!alreadyAdded) {
// we are adding the resource anyway.
((ResourceImpl) resource).prepareContentForPut();
persistServiceResource(registry, resource, servicePath);
}
/*
if (!servicePath.contains(registry.getRegistryContext().getServicePath())) {
if (defaultEnvironment == null) {
String serviceDefaultEnvironment = registry.getRegistryContext().getServicePath();
String relativePath = serviceDefaultEnvironment.replace(RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH, "");
relativePath = relativePath.replace(CommonUtil.derivePathFragmentFromNamespace(serviceNamespace),"");
defaultEnvironment = relativePath;
}
String currentRelativePath = servicePath.substring(0, servicePath.indexOf(CommonUtil.derivePathFragmentFromNamespace(serviceNamespace)));
currentRelativePath = currentRelativePath.replace(RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH,"");
String endpointEnv = EndpointUtils.getEndpointLocation();
String[] pathSegments = defaultEnvironment.split(RegistryConstants.PATH_SEPARATOR);
for (String pathSegment : pathSegments) {
endpointEnv = endpointEnv.replace(pathSegment,"");
currentRelativePath = currentRelativePath.replace(pathSegment,"");
}
while(endpointEnv.startsWith(RegistryConstants.PATH_SEPARATOR)){
endpointEnv = endpointEnv.replaceFirst(RegistryConstants.PATH_SEPARATOR,"");
}
environment = currentRelativePath + endpointEnv;
}
*/
EndpointUtils.saveEndpointsFromServices(
servicePath,
serviceInfoElement,
registry,
CommonUtil.getUnchrootedSystemRegistry(requestContext));
String symlinkLocation =
RegistryUtils.getAbsolutePath(
requestContext.getRegistryContext(),
requestContext.getResource().getProperty(RegistryConstants.SYMLINK_PROPERTY_NAME));
if (!servicePath.equals(originalServicePath)) {
// we are creating a sym link from service path to original service path.
Resource serviceResource =
requestContext.getRegistry().get(RegistryUtils.getParentPath(originalServicePath));
String isLink = serviceResource.getProperty("registry.link");
String mountPoint = serviceResource.getProperty("registry.mountpoint");
String targetPoint = serviceResource.getProperty("registry.targetpoint");
String actualPath = serviceResource.getProperty("registry.actualpath");
if (isLink != null && mountPoint != null && targetPoint != null) {
symlinkLocation = actualPath + RegistryConstants.PATH_SEPARATOR;
}
if (symlinkLocation != null) {
requestContext
.getSystemRegistry()
.createLink(symlinkLocation + resourceName, servicePath);
}
}
// in this flow the resource is already added. marking the process completed..
requestContext.setProcessingComplete(true);
if (wsdl != null
&& CommonConstants.ENABLE.equals(
System.getProperty(CommonConstants.UDDI_SYSTEM_PROPERTY))) {
AuthToken authToken = UDDIUtil.getPublisherAuthToken();
if (authToken == null) {
return;
}
// creating the business service info bean
BusinessServiceInfo businessServiceInfo = new BusinessServiceInfo();
// Following lines removed for fixing REGISTRY-1898.
// businessServiceInfo.setServiceName(serviceName.trim());
// businessServiceInfo.setServiceNamespace(serviceNamespace.trim());
//
// businessServiceInfo.setServiceEndpoints(CommonUtil.getEndpointEntries(serviceInfoElement));
//
// businessServiceInfo.setDocuments(CommonUtil.getDocLinks(serviceInfoElement));
businessServiceInfo.setServiceDescription(
CommonUtil.getServiceDescription(serviceInfoElement));
WSDLInfo wsdlInfo = wsdl.getMasterWSDLInfo();
businessServiceInfo.setServiceWSDLInfo(wsdlInfo);
UDDIPublisher publisher = new UDDIPublisher();
publisher.publishBusinessService(authToken, businessServiceInfo);
}
String path =
RegistryUtils.getRelativePathToOriginal(
servicePath, RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH);
ArtifactManager.getArtifactManager().getTenantArtifactRepository().addArtifact(path);
} finally {
CommonUtil.releaseUpdateLock();
}
}
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;
}
/**
* Adds the given WSDL artifact to the registry.
*
* @param wsdl the WSDL artifact.
* @throws GovernanceException if the operation failed.
*/
public void addWsdl(Wsdl wsdl) throws GovernanceException {
boolean succeeded = false;
try {
registry.beginTransaction();
String url = wsdl.getUrl();
Resource wsdlResource = registry.newResource();
wsdlResource.setMediaType(GovernanceConstants.WSDL_MEDIA_TYPE);
// setting the wsdl content
setContent(wsdl, wsdlResource);
wsdlResource.setUUID(wsdl.getId());
String tmpPath;
if (wsdl.getQName() != null) {
tmpPath = "/" + wsdl.getQName().getLocalPart();
} else if (url != null && !url.startsWith("name://")) {
tmpPath = RegistryUtils.getResourceName(new URL(url).getFile().replace("~", ""));
} else if (url != null) {
tmpPath = url.substring("name://".length());
} else {
tmpPath = wsdl.getId() + ".wsdl";
}
// OK this is a hack to get the UUID of the newly added artifact. This needs to be fixed
// properly with the fix for UUID support at Kernel-level - Janaka.
// Resource resource;
if (url == null || url.startsWith("name://")) {
// resource = registry.get(registry.put("/" + tmpPath, wsdlResource));
registry.put("/" + tmpPath, wsdlResource);
} else {
// resource = registry.get(registry.importResource(tmpPath, url,
// wsdlResource));
registry.importResource(tmpPath, url, wsdlResource);
}
// wsdl.setId(resource.getUUID());
wsdl.updatePath();
// wsdl.loadWsdlDetails();
succeeded = true;
} catch (RegistryException e) {
String msg = "Error in adding the wsdl. wsdl id: " + wsdl.getId() + ".";
log.error(msg, e);
throw new GovernanceException(msg, e);
} catch (MalformedURLException e) {
String msg = "Malformed policy url provided. url: " + wsdl.getUrl() + ".";
log.error(msg, e);
throw new GovernanceException(msg, e);
} finally {
if (succeeded) {
try {
registry.commitTransaction();
} catch (RegistryException e) {
String msg =
"Error in committing transactions. Add wsdl failed: wsdl id: "
+ wsdl.getId()
+ ", path: "
+ wsdl.getPath()
+ ".";
log.error(msg, e);
}
} else {
try {
registry.rollbackTransaction();
} catch (RegistryException e) {
String msg =
"Error in rolling back transactions. Add wsdl failed: wsdl id: "
+ wsdl.getId()
+ ", path: "
+ wsdl.getPath()
+ ".";
log.error(msg, e);
}
}
}
}
public void put(RequestContext requestContext) throws RegistryException {
Resource resource = requestContext.getResource();
Object content = resource.getContent();
String contentString;
if (content instanceof String) {
contentString = (String) content;
} else {
contentString = RegistryUtils.decodeBytes((byte[]) content);
}
OMElement payload;
try {
payload = AXIOMUtil.stringToOM(contentString);
} catch (XMLStreamException e) {
String msg = "Unable to serialize resource content";
log.error(msg, e);
throw new RegistryException(msg, e);
}
OMNamespace namespace = payload.getNamespace();
String namespaceURI = namespace.getNamespaceURI();
OMElement definition = payload.getFirstChildWithName(new QName(namespaceURI, "definition"));
OMElement projectPath =
definition.getFirstChildWithName(new QName(namespaceURI, "projectPath"));
String projectMetadataPath = null;
if (projectPath != null) {
projectMetadataPath = RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH + projectPath.getText();
}
Resource metadataResource = requestContext.getRegistry().get(projectMetadataPath);
String remainingWork = metadataResource.getProperty("Remaining Work");
String scheduledWork = metadataResource.getProperty("Scheduled Work");
String actualWork = metadataResource.getProperty("Actual Work");
String remainingCost = metadataResource.getProperty("Remaining Cost");
String scheduledCost = metadataResource.getProperty("Scheduled Cost");
String actualCost = metadataResource.getProperty("Actual Cost");
String duration = metadataResource.getProperty("Duration");
String startDate = metadataResource.getProperty("Start Date");
String endDate = metadataResource.getProperty("Finish Date");
OMFactory factory = payload.getOMFactory();
OMElement work = payload.getFirstChildWithName(new QName(namespaceURI, "work"));
if (work == null) {
work = factory.createOMElement("work", namespace, payload);
}
OMElement remainingWorkElement =
work.getFirstChildWithName(new QName(namespaceURI, "remaining"));
if (remainingWorkElement == null) {
remainingWorkElement = factory.createOMElement("remaining", namespace, work);
}
remainingWorkElement.setText(remainingWork);
OMElement actualWorkElement = work.getFirstChildWithName(new QName(namespaceURI, "actual"));
if (actualWorkElement == null) {
actualWorkElement = factory.createOMElement("actual", namespace, work);
}
actualWorkElement.setText(remainingWork);
OMElement scheduledWorkElement =
work.getFirstChildWithName(new QName(namespaceURI, "scheduled"));
if (scheduledWorkElement == null) {
scheduledWorkElement = factory.createOMElement("scheduled", namespace, work);
}
scheduledWorkElement.setText(remainingWork);
OMElement cost = payload.getFirstChildWithName(new QName(namespaceURI, "cost"));
if (cost == null) {
cost = factory.createOMElement("cost", namespace, payload);
}
OMElement remainingCostElement =
cost.getFirstChildWithName(new QName(namespaceURI, "remaining"));
if (remainingCostElement == null) {
remainingCostElement = factory.createOMElement("remaining", namespace, cost);
}
remainingCostElement.setText(remainingCost);
OMElement actualCostElement = cost.getFirstChildWithName(new QName(namespaceURI, "actual"));
if (actualCostElement == null) {
actualCostElement = factory.createOMElement("actual", namespace, cost);
}
actualCostElement.setText(remainingCost);
OMElement scheduledCostElement =
cost.getFirstChildWithName(new QName(namespaceURI, "scheduled"));
if (scheduledCostElement == null) {
scheduledCostElement = factory.createOMElement("scheduled", namespace, cost);
}
scheduledCostElement.setText(remainingCost);
OMElement timeline = payload.getFirstChildWithName(new QName(namespaceURI, "timeline"));
if (timeline == null) {
timeline = factory.createOMElement("timeline", namespace, payload);
}
OMElement durationElement = timeline.getFirstChildWithName(new QName(namespaceURI, "duration"));
if (durationElement == null) {
durationElement = factory.createOMElement("duration", namespace, timeline);
}
durationElement.setText(duration);
OMElement startDateElement =
timeline.getFirstChildWithName(new QName(namespaceURI, "startDate"));
if (startDateElement == null) {
startDateElement = factory.createOMElement("startDate", namespace, timeline);
}
startDateElement.setText(startDate);
OMElement endDateElement = timeline.getFirstChildWithName(new QName(namespaceURI, "endDate"));
if (endDateElement == null) {
endDateElement = factory.createOMElement("endDate", namespace, timeline);
}
endDateElement.setText(endDate);
resource.setContent(payload.toString());
}
/**
* Returns the root location of the endpoint.
*
* @param registryContext registry context
* @return The root location of the Endpoint artifact.
*/
private static String getChrootedEndpointLocation(RegistryContext registryContext) {
return RegistryUtils.getAbsolutePath(
registryContext, RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH + commonEndpointLocation);
}
public void testLifecycle() throws RegistryException {
Resource r1 = registry.newResource();
byte[] r1content = RegistryUtils.encodeString("R1 content");
r1.setContent(r1content);
registry.put("/d12/r1", r1);
String text1 = "this can be used as a test resource.";
String text2 = "I like this";
final Comment comment1 = new Comment(text1);
comment1.setUser("someone");
registry.addComment("/d12/r1", comment1);
final Comment comment2 = new Comment(text2);
comment2.setUser("someone");
registry.addComment("/d12/r1", comment2);
Comment[] comments = registry.getComments("/d12/r1");
Assert.assertNotNull(registry.get("/d12/r1").getContent());
boolean commentFound = false;
for (Comment comment : comments) {
if (comment.getText().equals(text1)) {
commentFound = true;
break;
}
}
Assert.assertTrue(
"comment '" + text1 + "' is not associated with the artifact /d12/r1", commentFound);
Resource commentsResource = registry.get("/d12/r1;comments");
Assert.assertTrue(
"Comment collection resource should be a directory.",
commentsResource instanceof Collection);
comments = (Comment[]) commentsResource.getContent();
List commentTexts = new ArrayList();
for (Comment comment : comments) {
Resource commentResource = registry.get(comment.getPath());
commentTexts.add(commentResource.getContent());
}
Assert.assertTrue(
text1 + " is not associated for resource /d12/r1.", commentTexts.contains(text1));
Assert.assertTrue(
text2 + " is not associated for resource /d12/r1.", commentTexts.contains(text2));
registry.associateAspect("/d12/r1", LIFECYCLE_NAME);
registry.invokeAspect("/d12/r1", LIFECYCLE_NAME, "promote");
Resource resource = registry.get("/developed/d12/r1");
Assert.assertNotNull(resource);
Assert.assertNotNull(resource.getContent());
comments = registry.getComments("/developed/d12/r1");
commentFound = false;
for (Comment comment : comments) {
if (comment.getText().equals(text1)) {
commentFound = true;
break;
}
}
Assert.assertTrue(
"comment '" + text1 + "' is not associated with the artifact /developed/d12/r1",
commentFound);
commentsResource = registry.get("/developed/d12/r1;comments");
Assert.assertTrue(
"Comment collection resource should be a directory.",
commentsResource instanceof Collection);
comments = (Comment[]) commentsResource.getContent();
commentTexts = new ArrayList();
for (Comment comment : comments) {
Resource commentResource = registry.get(comment.getPath());
commentTexts.add(commentResource.getContent());
}
Assert.assertTrue(
text1 + " is not associated for resource /developed/d12/r1.", commentTexts.contains(text1));
Assert.assertTrue(
text2 + " is not associated for resource /developed/d12/r1.", commentTexts.contains(text2));
}
public String addWadlToRegistry(
RequestContext requestContext, Resource resource, String resourcePath, boolean skipValidation)
throws RegistryException {
String wadlName = RegistryUtils.getResourceName(resourcePath);
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);
}
OMElement wadlElement;
String wadlContent;
Object resourceContent = resource.getContent();
if (resourceContent instanceof String) {
wadlContent = (String) resourceContent;
} else {
wadlContent = new String((byte[]) resourceContent);
}
try {
XMLStreamReader reader =
XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(wadlContent));
StAXOMBuilder builder = new StAXOMBuilder(reader);
wadlElement = builder.getDocumentElement();
} catch (XMLStreamException e) {
// This exception is unexpected because the WADL already validated
String msg = "Unexpected error occured " + "while reading the WADL at " + resourcePath + ".";
log.error(msg);
throw new RegistryException(msg, e);
}
String wadlNamespace = wadlElement.getNamespace().getNamespaceURI();
String namespaceSegment =
CommonUtil.derivePathFragmentFromNamespace(wadlNamespace).replace("//", "/");
String actualPath =
getChrootedWadlLocation(requestContext.getRegistryContext())
+ namespaceSegment
+ version
+ "/"
+ wadlName;
OMElement grammarsElement =
wadlElement.getFirstChildWithName(new QName(wadlNamespace, "grammars"));
if (StringUtils.isNotBlank(requestContext.getSourceURL())) {
String uri = requestContext.getSourceURL();
if (!skipValidation) {
validateWADL(uri);
}
if (resource.getUUID() == null) {
resource.setUUID(UUID.randomUUID().toString());
}
String wadlBaseUri = uri.substring(0, uri.lastIndexOf("/") + 1);
if (grammarsElement != null) {
// This is to avoid evaluating the grammars import when building AST
grammarsElement.detach();
wadlElement.addChild(resolveImports(grammarsElement, wadlBaseUri, version));
}
} else {
if (!skipValidation) {
File tempFile = null;
BufferedWriter bufferedWriter = null;
try {
tempFile = File.createTempFile(wadlName, null);
bufferedWriter = new BufferedWriter(new FileWriter(tempFile));
bufferedWriter.write(wadlElement.toString());
bufferedWriter.flush();
} catch (IOException e) {
String msg = "Error occurred while reading the WADL File";
log.error(msg, e);
throw new RegistryException(msg, e);
} finally {
if (bufferedWriter != null) {
try {
bufferedWriter.close();
} catch (IOException e) {
String msg = "Error occurred while closing File writer";
log.warn(msg, e);
}
}
}
validateWADL(tempFile.toURI().toString());
try {
delete(tempFile);
} catch (IOException e) {
String msg =
"An error occurred while deleting the temporary files from local file system.";
log.warn(msg, e);
throw new RegistryException(msg, e);
}
}
if (grammarsElement != null) {
grammarsElement = resolveImports(grammarsElement, null, version);
wadlElement.addChild(grammarsElement);
}
}
requestContext.setResourcePath(new ResourcePath(actualPath));
if (resource.getProperty(CommonConstants.SOURCE_PROPERTY) == null) {
resource.setProperty(CommonConstants.SOURCE_PROPERTY, CommonConstants.SOURCE_AUTO);
}
registry.put(actualPath, resource);
addImportAssociations(actualPath);
if (getCreateService()) {
OMElement serviceElement =
RESTServiceUtils.createRestServiceArtifact(
wadlElement,
wadlName,
version,
RegistryUtils.getRelativePath(requestContext.getRegistryContext(), actualPath));
String servicePath = RESTServiceUtils.addServiceToRegistry(requestContext, serviceElement);
registry.addAssociation(servicePath, actualPath, CommonConstants.DEPENDS);
registry.addAssociation(actualPath, servicePath, CommonConstants.USED_BY);
String endpointPath = createEndpointElement(requestContext, wadlElement, version);
if (endpointPath != null) {
registry.addAssociation(servicePath, endpointPath, CommonConstants.DEPENDS);
registry.addAssociation(endpointPath, servicePath, CommonConstants.USED_BY);
}
}
return resource.getPath();
}
