import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
@Override
public Set<String> findDescendantResources(String parentResourceId, EvaluationCtx context) throws Exception {
    Set<String> resourceSet = new HashSet<String>();
    registry = EntitlementServiceComponent.getRegistryService().getSystemRegistry(CarbonContext.
            getThreadLocalCarbonContext().getTenantId());
    if (registry.resourceExists(parentResourceId)) {
        Resource resource = registry.get(parentResourceId);
        if (resource instanceof Collection) {
            Collection collection = (Collection) resource;
            String[] resources = collection.getChildren();
            for (String res : resources) {
                resourceSet.add(res);
                getChildResources(res, resourceSet);
            }
        } else {
            return null;
        }
    }
    return resourceSet;
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
/**
 * This helps to find resources un a recursive manner
 *
 * @param node           attribute value node
 * @param parentResource parent resource Name
 * @return child resource set
 * @throws RegistryException throws
 */
private EntitlementTreeNodeDTO getChildResources(EntitlementTreeNodeDTO node,
                                                 String parentResource) throws RegistryException {

    if (registry.resourceExists(parentResource)) {
        String[] resourcePath = parentResource.split("/");
        EntitlementTreeNodeDTO childNode =
                new EntitlementTreeNodeDTO(resourcePath[resourcePath.length - 1]);
        node.addChildNode(childNode);
        Resource root = registry.get(parentResource);
        if (root instanceof Collection) {
            Collection collection = (Collection) root;
            String[] resources = collection.getChildren();
            for (String resource : resources) {
                getChildResources(childNode, resource);
            }
        }
    }
    return node;
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
private void buildUIPermissionNodeAllSelected(Collection parent, UIPermissionNode parentNode,
                                              Registry registry, Registry tenantRegistry) throws RegistryException,
        UserStoreException {

    String[] children = parent.getChildren();
    UIPermissionNode[] childNodes = new UIPermissionNode[children.length];
    for (int i = 0; i < children.length; i++) {
        String child = children[i];
        Resource resource = null;

        if (registry.resourceExists(child)) {
            resource = registry.get(child);
        } else if (tenantRegistry != null) {
            resource = tenantRegistry.get(child);
        } else {
            throw new RegistryException("Permission resource not found in the registry.");
        }

        childNodes[i] = getUIPermissionNode(resource, true);
        if (resource instanceof Collection) {
            buildUIPermissionNodeAllSelected((Collection) resource, childNodes[i], registry,
                    tenantRegistry);
        }
    }
    parentNode.setNodeList(childNodes);
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
@Override
public String getSpeedAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException {
    try {
        Registry registry = getGovernanceRegistry();
        Resource resource = registry.get(GeoServices.REGISTRY_PATH_FOR_ALERTS +
                                                 GeoServices.ALERT_TYPE_SPEED + "/" + identifier.getId());
        if (resource == null) {
            return "{'content': false}";
        }
        InputStream inputStream = resource.getContentStream();
        StringWriter writer = new StringWriter();
        IOUtils.copy(inputStream, writer, "UTF-8");
        return "{'speedLimit':" + writer.toString() + "}";
    } catch (RegistryException | IOException e) {
        return "{'content': false}";
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
@Override
public String getProximityAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException {
    try {
        Registry registry = getGovernanceRegistry();
        Resource resource = registry.get(GeoServices.REGISTRY_PATH_FOR_ALERTS +
                                                 GeoServices.ALERT_TYPE_PROXIMITY
                                                 + "/" + identifier.getId());
        if (resource != null) {
            Properties props = resource.getProperties();

            List proxDisObj = (List) props.get(GeoServices.PROXIMITY_DISTANCE);
            List proxTimeObj = (List) props.get(GeoServices.PROXIMITY_TIME);

            return String.format("{proximityDistance:\"%s\", proximityTime:\"%s\"}",
                                 proxDisObj != null ? proxDisObj.get(0).toString() : "",
                                 proxTimeObj != null ? proxTimeObj.get(0).toString() : "");
        } else {
            return "{'content': false}";
        }
    } catch (RegistryException e) {
        return "{'content': false}";
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
private void updateRegistry(String path, DeviceIdentifier identifier, Object content, Map<String, String> options)
        throws GeoLocationBasedServiceException {
    try {

        Registry registry = getGovernanceRegistry();
        Resource newResource = registry.newResource();
        newResource.setContent(content);
        newResource.setMediaType("application/json");
        for (Map.Entry<String, String> option : options.entrySet()) {
            newResource.addProperty(option.getKey(), option.getValue());
        }
        registry.put(path, newResource);
    } catch (RegistryException e) {
        throw new GeoLocationBasedServiceException(
                "Error occurred while setting the Within Alert for " + identifier.getType() + " with id: " +
                        identifier.getId(), e);
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
public static boolean putRegistryResource(String path,
                                          Resource resource)
		throws ConfigurationManagementException {
	boolean status;
	try {
		ConfigurationManagerUtil.getConfigurationRegistry().beginTransaction();
		ConfigurationManagerUtil.getConfigurationRegistry().put(path, resource);
		ConfigurationManagerUtil.getConfigurationRegistry().commitTransaction();
		status = true;
	} catch (RegistryException e) {
		throw new ConfigurationManagementException(
				"Error occurred while persisting registry resource : " +
				e.getMessage(), e);
	}
	return status;
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
@Override
public void write(String outPath, InputStream in) throws MLOutputAdapterException {

    if (in == null || outPath == null) {
        throw new MLOutputAdapterException(String.format(
                "Null argument values detected. Input stream: %s Out Path: %s", in, outPath));
    }
    try {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        IOUtils.copy(in, byteArrayOutputStream);
        byte[] array = byteArrayOutputStream.toByteArray();

        PrivilegedCarbonContext carbonContext = PrivilegedCarbonContext.getThreadLocalCarbonContext();
        Registry registry = carbonContext.getRegistry(RegistryType.SYSTEM_GOVERNANCE);
        Resource resource = registry.newResource();
        resource.setContent(array);
        registry.put(outPath, resource);

    } catch (RegistryException | IOException e) {
        throw new MLOutputAdapterException(
                String.format("Failed to save the model to registry %s: %s", outPath, e), e);
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
/**
 * Add a trusted service to which tokens are issued with given claims.
 *
 * @param realmName    - this uniquely represents the trusted service
 * @param claimDialect - claim dialects uris
 * @param claims       - these comma separated default claims are issued when a request is done from the given realm
 * @throws Exception - if fails to add trusted service
 */
public void addTrustedService(String realmName, String claimDialect, String claims)
        throws Exception {
    realmName = replaceSlashWithConstantString(realmName);
    try {
        Registry registry = IdentityPassiveSTSServiceComponent.getConfigSystemRegistry();
        String trustedServicePath = registryTrustedServicePath + realmName;
        // if registry collection does not exists, create
        if (!registry.resourceExists(trustedServicePath)) {
            Resource resource = registry.newResource();
            resource.addProperty(REALM_NAME, realmName);
            resource.addProperty(CLAIMS, claims);
            resource.addProperty(CLAIM_DIALECT, claimDialect);
            registry.put(trustedServicePath, resource);
        } else {
            throw new Exception(realmName + " already added. Please remove first and add again.");
        }
    } catch (RegistryException e) {
        String error = "Error occurred when adding a trusted service due to error in accessing registry.";
        throw new Exception(error, e);
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
/**
 * Get DAS config details of given certain process which are configured for analytics from the config registry
 *
 * @param processDefinitionId Process definition ID
 * @return KPI configuration details in JSON format. Ex:<p>
 * {"processDefinitionId":"myProcess3:1:32518","eventStreamName":"t_666_process_stream","eventStreamVersion":"1.0.0"
 * ,"eventStreamDescription":"This is the event stream generated to configure process analytics with DAS, for the
 * processt_666","eventStreamNickName":"t_666_process_stream","eventStreamId":"t_666_process_stream:1.0.0",
 * "eventReceiverName":"t_666_process_receiver","pcProcessId":"t:666",
 * "processVariables":[{"name":"processInstanceId","type":"string","isAnalyzeData":"false",
 * "isDrillDownData":"false"}
 * ,{"name":"valuesAvailability","type":"string","isAnalyzeData":"false","isDrillDownData":"false"}
 * ,{"name":"custid","type":"string","isAnalyzeData":false,"isDrillDownData":false}
 * ,{"name":"amount","type":"long","isAnalyzeData":false,"isDrillDownData":false}
 * ,{"name":"confirm","type":"bool","isAnalyzeData":false,"isDrillDownData":false}]}
 * @throws RegistryException
 */
public JsonNode getKPIConfiguration(String processDefinitionId) throws RegistryException, IOException {
    String resourcePath = AnalyticsPublisherConstants.REG_PATH_BPMN_ANALYTICS + processDefinitionId + "/"
            + AnalyticsPublisherConstants.ANALYTICS_CONFIG_FILE_NAME;
    try {
        RegistryService registryService = BPMNAnalyticsHolder.getInstance().getRegistryService();
        Registry configRegistry = registryService.getConfigSystemRegistry();

        if (configRegistry.resourceExists(resourcePath)) {
            Resource processRegistryResource = configRegistry.get(resourcePath);
            String dasConfigDetailsJSONStr = new String((byte[]) processRegistryResource.getContent(),
                    StandardCharsets.UTF_8);
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.readTree(dasConfigDetailsJSONStr);
        }
        return null;

    } catch (RegistryException e) {
        String errMsg = "Error in Getting DAS config details of given process definition id :" + processDefinitionId
                + " from the BPS Config registry-" + resourcePath;
        throw new RegistryException(errMsg, e);
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
/**
 * Get the checksum of latest deployment for given deployment name
 *
 * @param deploymentName
 * @return
 * @throws BPSFault
 */
public String getLatestChecksum(String deploymentName) throws BPSFault {

    try {
        Integer tenantId = CarbonContext.getThreadLocalCarbonContext().getTenantId();
        RegistryService registryService = BPMNServerHolder.getInstance().getRegistryService();
        Registry tenantRegistry = registryService.getConfigSystemRegistry(tenantId);
        String deploymentRegistryPath = BPMNConstants.BPMN_REGISTRY_PATH + BPMNConstants.REGISTRY_PATH_SEPARATOR
                + deploymentName;
        if (tenantRegistry.resourceExists(deploymentRegistryPath)) {
            Resource deploymentEntry = tenantRegistry.get(deploymentRegistryPath);
            return deploymentEntry.getProperty(BPMNConstants.LATEST_CHECKSUM_PROPERTY);
        } else {
            return null;
        }
    } catch (RegistryException e) {
        String msg = "Error while accessing registry to get latest checksum for package : " + deploymentName;
        throw new BPSFault(msg, e);
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
@Override
public void delete(RequestContext requestContext) throws RegistryException {
    Resource resource = requestContext.getResource();
    if (resource instanceof Collection) {
        if(!isDeleteLockAvailable()){
            return;
        }
        acquireDeleteLock();
        try {
            deleteRecursively(requestContext.getRegistry(), resource);
            requestContext.setProcessingComplete(true);
        } finally {
            releaseDeleteLock();
        }
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
/**
 * This helps to find resources un a recursive manner
 *
 * @param parentResource parent resource Name
 * @param childResources child resource set
 * @return child resource set
 * @throws RegistryException throws
 */
private Set<String> getChildResources(String parentResource, Set<String> childResources)
        throws RegistryException {

    Resource resource = registry.get(parentResource);
    if (resource instanceof Collection) {
        Collection collection = (Collection) resource;
        String[] resources = collection.getChildren();
        for (String res : resources) {
            childResources.add(res);
            getChildResources(res, childResources);
        }
    }
    return childResources;
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
@Override
public void persistConfig(String policyEditorType, String xmlConfig) throws PolicyEditorException {

    super.persistConfig(policyEditorType, xmlConfig);

    Registry registry = CarbonContext.getThreadLocalCarbonContext().getRegistry(RegistryType.SYSTEM_GOVERNANCE);
    try {
        Resource resource = registry.newResource();
        resource.setContent(xmlConfig);
        String path = null;
        if (EntitlementConstants.PolicyEditor.BASIC.equals(policyEditorType)) {
            path = EntitlementConstants.ENTITLEMENT_POLICY_BASIC_EDITOR_CONFIG_FILE_REGISTRY_PATH;
        } else if (EntitlementConstants.PolicyEditor.STANDARD.equals(policyEditorType)) {
            path = EntitlementConstants.ENTITLEMENT_POLICY_STANDARD_EDITOR_CONFIG_FILE_REGISTRY_PATH;
        } else if (EntitlementConstants.PolicyEditor.RBAC.equals(policyEditorType)) {
            path = EntitlementConstants.ENTITLEMENT_POLICY_RBAC_EDITOR_CONFIG_FILE_REGISTRY_PATH;
        } else if (EntitlementConstants.PolicyEditor.SET.equals(policyEditorType)) {
            path = EntitlementConstants.ENTITLEMENT_POLICY_SET_EDITOR_CONFIG_FILE_REGISTRY_PATH;
        } else {
            //default
            path = EntitlementConstants.ENTITLEMENT_POLICY_BASIC_EDITOR_CONFIG_FILE_REGISTRY_PATH;
        }
        registry.put(path, resource);
    } catch (RegistryException e) {
        throw new PolicyEditorException("Error while persisting policy editor config");
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
/**
 * Check if resource has expired and delete.
 *
 * @param registry Registry instance to use.
 * @param resourcePath Path of resource to be deleted.
 * @throws RegistryException
 */
private static void checkAndDeleteRegistryResource (Registry registry, String resourcePath) throws
        RegistryException {

    Resource resource = registry.get(resourcePath);
    long currentEpochTime = System.currentTimeMillis();
    long resourceExpireTime = Long.parseLong(resource.getProperty(EXPIRE_TIME_PROPERTY));
    if (currentEpochTime > resourceExpireTime) {

        registry.delete(resource.getId());
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
private void buildUIPermissionNodeNotAllSelected(Collection parent, UIPermissionNode parentNode,
                                                 Registry registry, Registry tenantRegistry,
                                                 AuthorizationManager authMan, String roleName, String userName)
        throws RegistryException, UserStoreException {

    String[] children = parent.getChildren();
    UIPermissionNode[] childNodes = new UIPermissionNode[children.length];

    for (int i = 0; i < children.length; i++) {
        String child = children[i];
        Resource resource = null;

        if (tenantRegistry != null && child.startsWith("/permission/applications")) {
            resource = tenantRegistry.get(child);
        } else if (registry.resourceExists(child)) {
            resource = registry.get(child);
        } else {
            throw new RegistryException("Permission resource not found in the registry.");
        }

        boolean isSelected = false;
        if (roleName != null) {
            isSelected = authMan.isRoleAuthorized(roleName, child,
                    UserMgtConstants.EXECUTE_ACTION);
        } else if (userName != null) {
            isSelected = authMan.isUserAuthorized(userName, child,
                    UserMgtConstants.EXECUTE_ACTION);
        }
        childNodes[i] = getUIPermissionNode(resource, isSelected);
        if (resource instanceof Collection) {
            buildUIPermissionNodeNotAllSelected((Collection) resource, childNodes[i],
                    registry, tenantRegistry, authMan, roleName, userName);
        }
    }
    parentNode.setNodeList(childNodes);
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
public static boolean putRegistryResource(String path, Resource resource) throws DeviceTypeMgtPluginException {
    try {
        Registry registry = getConfigurationRegistry();
        registry.beginTransaction();
        registry.put(path, resource);
        registry.commitTransaction();
        return true;
    } catch (RegistryException e) {
        throw new DeviceTypeMgtPluginException(
                "Error occurred while persisting registry resource : " + e.getMessage(), e);
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
public static Resource getRegistryResource(String path) throws DeviceTypeMgtPluginException {
    try {
        if(DeviceTypeUtils.getConfigurationRegistry().resourceExists(path)){
            return DeviceTypeUtils.getConfigurationRegistry().get(path);
        }
        return null;
    } catch (RegistryException e) {
        throw new DeviceTypeMgtPluginException("Error in retrieving registry resource : " + e.getMessage(), e);
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
public static Permission getPermission(String path) throws PermissionManagementException {
    try {
        Resource resource = PermissionUtils.getGovernanceRegistry().get(path);
        Permission permission = new Permission();
        permission.setName(resource.getProperty(PERMISSION_PROPERTY_NAME));
        permission.setPath(resource.getPath());
        return permission;
    } catch (RegistryException e) {
        throw new PermissionManagementException("Error in retrieving registry resource : " +
                e.getMessage(), e);
    }
}
 

import org.wso2.carbon.registry.api.Resource; //导入依赖的package包/类
public static void createRegistryCollection(String path, String resourceName)
        throws PermissionManagementException,
        RegistryException {
    Resource resource = PermissionUtils.getGovernanceRegistry().newCollection();
    resource.addProperty(PERMISSION_PROPERTY_NAME, resourceName);
    PermissionUtils.getGovernanceRegistry().beginTransaction();
    PermissionUtils.getGovernanceRegistry().put(path, resource);
    PermissionUtils.getGovernanceRegistry().commitTransaction();
}