public boolean associationPathExists(String path, String assoPath) throws Exception { Association association[] = registry.getAllAssociations(path); boolean value = false; for (Association anAssociation : association) { if (assoPath.equals(anAssociation.getDestinationPath())) { value = true; } } return value; }
public boolean associationSourcepathExists(String path, String sourcePath) throws Exception { Association association[] = registry.getAllAssociations(path); boolean value = false; for (Association anAssociation : association) { anAssociation.getAssociationType(); if (sourcePath.equals(anAssociation.getSourcePath())) { value = true; } } return value; }
private void addRelationships(String path, GovernanceArtifact artifact) throws RegistryException { Map<String, AssociationInteger> typeMap = new LinkedHashMap<String, AssociationInteger>(); for (Association relationship : relationshipDefinitions) { String type = relationship.getAssociationType(); String source = relationship.getSourcePath(); String target = relationship.getDestinationPath(); if (typeMap.containsKey(type)) { AssociationInteger associationInteger = typeMap.get(type); if (source == null) { if (associationInteger.getInteger() < 0) { associationInteger.setInteger(0); } for (String targetPath : GovernanceUtils.getPathsFromPathExpression(target, artifact)) { associationInteger.getAssociations().add(new Association(path, targetPath, type)); } } else if (target == null) { if (associationInteger.getInteger() > 0) { associationInteger.setInteger(0); } for (String sourcePath : GovernanceUtils.getPathsFromPathExpression(source, artifact)) { associationInteger.getAssociations().add(new Association(sourcePath, path, type)); } } } else { AssociationInteger associationInteger = new AssociationInteger(); if (source == null) { associationInteger.setInteger(1); for (String targetPath : GovernanceUtils.getPathsFromPathExpression(target, artifact)) { associationInteger.getAssociations().add(new Association(path, targetPath, type)); } } else if (target == null) { associationInteger.setInteger(-1); for (String sourcePath : GovernanceUtils.getPathsFromPathExpression(source, artifact)) { associationInteger.getAssociations().add(new Association(sourcePath, path, type)); } } typeMap.put(type, associationInteger); } } for (Map.Entry<String, AssociationInteger> e : typeMap.entrySet()) { AssociationInteger value = e.getValue(); List<Association> associations = value.getAssociations(); fixAssociations( path, e.getKey(), value.getInteger() >= 0, value.getInteger() <= 0, associations.toArray(new Association[associations.size()])); } }
public boolean getAssocitionbySourceByType(String path, String type) throws Exception { Association[] asso; asso = registry.getAssociations(path, type); boolean assoFound = false; if (asso == null) { return assoFound; } for (Association a2 : asso) { if (a2.getSourcePath().equals(path)) { assoFound = true; break; } } return assoFound; }
private void fixAssociations( String path, String type, boolean isSource, boolean isTarget, Association[] toAdd) throws RegistryException { final String SEPARATOR = ":"; // Get the existing association list which is related to the current operation Set<String> existingSet = new HashSet<String>(); for (Association association : registry.getAllAssociations(path)) { if (type.equals(association.getAssociationType()) && ((isSource && association.getSourcePath().equals(path)) || (isTarget && association.getDestinationPath().equals(path)))) { existingSet.add( association.getSourcePath() + SEPARATOR + association.getDestinationPath() + SEPARATOR + association.getAssociationType()); } } // Get the updated association list from the projectGroup object Set<String> updatedSet = new HashSet<String>(); for (Association association : toAdd) { updatedSet.add( association.getSourcePath() + SEPARATOR + association.getDestinationPath() + SEPARATOR + association.getAssociationType()); } Set<String> removedAssociations = new HashSet<String>(existingSet); removedAssociations.removeAll(updatedSet); Set<String> newAssociations = new HashSet<String>(updatedSet); newAssociations.removeAll(existingSet); for (String removedAssociation : removedAssociations) { String[] params = removedAssociation.split(SEPARATOR); registry.removeAssociation(params[0], params[1], params[2]); } for (String newAssociation : newAssociations) { String[] params = newAssociation.split(SEPARATOR); registry.addAssociation(params[0], params[1], params[2]); } }
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(); } }