public void testDefaultQuery() throws Exception { Resource r1 = registry.newResource(); String r1Content = "this is r1 content"; r1.setContent(r1Content.getBytes()); r1.setDescription("production ready."); String r1Path = "/c3/r1"; registry.put(r1Path, r1); Resource r2 = registry.newResource(); String r2Content = "content for r2 :)"; r2.setContent(r2Content); r2.setDescription("ready for production use."); String r2Path = "/c3/r2"; registry.put(r2Path, r2); Resource r3 = registry.newResource(); String r3Content = "content for r3 :)"; r3.setContent(r3Content); r3.setDescription("only for government use."); String r3Path = "/c3/r3"; registry.put(r3Path, r3); registry.applyTag("/c3/r1", "java"); registry.applyTag("/c3/r2", "jsp"); registry.applyTag("/c3/r3", "ajax"); String sql1 = "SELECT RT.REG_TAG_ID FROM REG_RESOURCE_TAG RT, REG_RESOURCE R " + "WHERE (R.REG_VERSION=RT.REG_VERSION OR " + "(R.REG_PATH_ID=RT.REG_PATH_ID AND R.REG_NAME=RT.REG_RESOURCE_NAME)) " + "AND R.REG_DESCRIPTION LIKE ? ORDER BY RT.REG_TAG_ID"; Resource q1 = systemRegistry.newResource(); q1.setContent(sql1); q1.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE); q1.addProperty(RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.TAGS_RESULT_TYPE); systemRegistry.put("/qs/q3", q1); Map<String, String> parameters = new HashMap<String, String>(); parameters.put("1", "%production%"); Collection result = registry.executeQuery("/qs/q3", parameters); String[] tagPaths = result.getChildren(); assertEquals("There should be two matching tags.", tagPaths.length, 2); Resource tag2 = registry.get(tagPaths[0]); assertEquals("First matching tag should be 'java'", (String) tag2.getContent(), "java"); Resource tag1 = registry.get(tagPaths[1]); assertEquals("Second matching tag should be 'jsp'", (String) tag1.getContent(), "jsp"); }
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 void testBackwardCompatibility() throws RegistryException { Registry rootRegistry = embeddedRegistryService.getSystemRegistry(); Resource r1 = rootRegistry.newResource(); r1.setContent("r1 content"); rootRegistry.put("/test/comments/r1", r1); rootRegistry.addComment( "/test/comments/r1", new Comment("backward-compatibility1 on this resource :)")); rootRegistry.addComment( "/test/comments/r1", new Comment("backward-compatibility2 on this resource :)")); String sql = "SELECT REG_COMMENT_ID FROM REG_COMMENT C, REG_RESOURCE_COMMENT RC " + "WHERE C.REG_COMMENT_TEXT LIKE ? AND C.REG_ID=RC.REG_COMMENT_ID"; Resource queryR = rootRegistry.newResource(); queryR.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE); queryR.addProperty( RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.COMMENTS_RESULT_TYPE); rootRegistry.put("/beep/x", queryR); Map<String, String> params = new HashMap<String, String>(); params.put("query", sql); params.put(RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.COMMENTS_RESULT_TYPE); params.put("1", "backward-compatibility1%"); Collection qResults = rootRegistry.executeQuery("/beep/x", params); String[] qPaths = (String[]) qResults.getContent(); assertEquals("Query result count should be 1", qPaths.length, 1); }
public void testWithoutTableParamsQuery() throws Exception { Resource r1 = registry.newResource(); String r1Content = "this is r1 content"; r1.setContent(r1Content.getBytes()); r1.setDescription("production ready."); String r1Path = "/c1/r1"; registry.put(r1Path, r1); Resource r2 = registry.newResource(); String r2Content = "content for r2 :)"; r2.setContent(r2Content); r2.setDescription("ready for production use."); String r2Path = "/c2/r2"; registry.put(r2Path, r2); Resource r3 = registry.newResource(); String r3Content = "content for r3 :)"; r3.setContent(r3Content); r3.setDescription("only for government use."); String r3Path = "/c2/r3"; registry.put(r3Path, r3); String sql1 = "SELECT REG_PATH_ID, REG_NAME FROM REG_RESOURCE, " + "REG_TAG WHERE REG_DESCRIPTION LIKE ?"; Resource q1 = systemRegistry.newResource(); q1.setContent(sql1); q1.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE); q1.addProperty( RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.RESOURCES_RESULT_TYPE); systemRegistry.put("/qs/q1", q1); Map<String, String> parameters = new HashMap<String, String>(); parameters.put("1", "%production%"); Resource result = registry.executeQuery("/qs/q1", parameters); assertTrue( "Search with result type Resource should return a directory.", result instanceof org.wso2.carbon.registry.core.Collection); List<String> matchingPaths = new ArrayList<String>(); String[] paths = (String[]) result.getContent(); matchingPaths.addAll(Arrays.asList(paths)); assertTrue("Path /c1/r1 should be in the results.", matchingPaths.contains("/c1/r1")); assertTrue("Path /c2/r2 should be in the results.", matchingPaths.contains("/c2/r2")); }
public void testWithoutWhereQuery() throws Exception { Resource r1 = registry.newResource(); String r1Content = "this is r1 content"; r1.setContent(r1Content.getBytes()); r1.setDescription("production ready."); String r1Path = "/c1/r1"; registry.put(r1Path, r1); Resource r2 = registry.newResource(); String r2Content = "content for r2 :)"; r2.setContent(r2Content); r2.setDescription("ready for production use."); String r2Path = "/c2/r2"; registry.put(r2Path, r2); Resource r3 = registry.newResource(); String r3Content = "content for r3 :)"; r3.setContent(r3Content); r3.setDescription("only for government use."); String r3Path = "/c2/r3"; registry.put(r3Path, r3); String sql1 = "SELECT REG_PATH_ID, REG_NAME FROM REG_RESOURCE, REG_TAG"; Resource q1 = systemRegistry.newResource(); q1.setContent(sql1); q1.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE); q1.addProperty( RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.RESOURCES_RESULT_TYPE); systemRegistry.put("/qs/q1", q1); Map parameters = new HashMap(); Resource result = registry.executeQuery("/qs/q1", parameters); assertTrue( "Search with result type Resource should return a directory.", result instanceof org.wso2.carbon.registry.core.Collection); String[] paths = (String[]) result.getContent(); assertTrue("Should return all the resources", paths.length >= 3); }
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 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; }
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(); } }