/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.xd.dirt.module.store;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.apache.commons.collections.MapUtils;
import org.apache.curator.framework.CuratorFramework;
import org.apache.zookeeper.KeeperException.NoNodeException;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PlaceholderConfigurerSupport;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import org.springframework.xd.dirt.core.DeploymentUnitStatus;
import org.springframework.xd.dirt.core.ModuleDeploymentsPath;
import org.springframework.xd.dirt.stream.JobRepository;
import org.springframework.xd.dirt.stream.StreamRepository;
import org.springframework.xd.dirt.util.PagingUtility;
import org.springframework.xd.dirt.zookeeper.Paths;
import org.springframework.xd.dirt.zookeeper.ZooKeeperConnection;
import org.springframework.xd.dirt.zookeeper.ZooKeeperUtils;
import org.springframework.xd.module.ModuleType;
/**
* ZooKeeper backed repository for runtime info about deployed modules.
*
* @author Ilayaperumal Gopinathan
* @author David Turanski
*/
public class ZooKeeperModuleMetadataRepository implements ModuleMetadataRepository {
private static final String XD_MODULE_PROPERTIES_PREFIX = "xd.";
private final ZooKeeperConnection zkConnection;
private final StreamRepository streamRepository;
private final JobRepository jobRepository;
private final PagingUtility<ModuleMetadata> pagingUtility = new PagingUtility<ModuleMetadata>();
private final Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
public ZooKeeperModuleMetadataRepository(ZooKeeperConnection zkConnection,
StreamRepository streamRepository,
JobRepository jobRepository) {
this.zkConnection = zkConnection;
this.streamRepository = streamRepository;
this.jobRepository = jobRepository;
}
@Override
public Iterable<ModuleMetadata> findAll(Sort sort) {
// todo: add support for sort
return findAll();
}
@Override
public Page<ModuleMetadata> findAll(Pageable pageable) {
return pagingUtility.getPagedData(pageable, findAll());
}
/**
* {@inheritDoc}
*/
@Override
public ModuleMetadata findOne(String containerId, String moduleId) {
return findOne(new ModuleMetadata.Id(containerId, moduleId));
}
/**
* {@inheritDoc}
*/
@Override
public Page<ModuleMetadata> findAllByContainerId(Pageable pageable, String containerId) {
Assert.hasText(containerId, "containerId is required");
return pagingUtility.getPagedData(pageable, findAllByContainerId(containerId));
}
/**
* {@inheritDoc}
*/
@Override
public Page<ModuleMetadata> findAllByModuleId(Pageable pageable, String moduleId) {
Assert.hasText(moduleId, "moduleId is required");
List<ModuleMetadata> results = new ArrayList<ModuleMetadata>();
for (String containerId : getAvailableContainerIds()) {
ModuleMetadata metadata = findOne(new ModuleMetadata.Id(containerId, moduleId));
if (metadata != null) {
results.add(metadata);
}
}
return pagingUtility.getPagedData(pageable, results);
}
/**
* {@inheritDoc}
* <p>
* Find the module metadata for the modules that are deployed into the
* given container and module metadata id.
*
* @param id unique id for module deployment
*
* @return {@link ModuleMetadata} of the module.
*/
@Override
public ModuleMetadata findOne(ModuleMetadata.Id id) {
Assert.notNull(id, "id is required");
String moduleDeploymentPath = moduleDeploymentPath(id);
String metadataPath = Paths.build(moduleDeploymentPath, Paths.METADATA);
ModuleMetadata metadata = null;
try {
byte[] data = zkConnection.getClient().getData().forPath(metadataPath);
if (data != null) {
Map<String, String> metadataMap = ZooKeeperUtils.bytesToMap(data);
ModuleDeploymentsPath p = new ModuleDeploymentsPath(moduleDeploymentPath);
ModuleType moduleType = id.getModuleType();
DeploymentUnitStatus status = moduleType == ModuleType.job
? jobRepository.getDeploymentStatus(id.getUnitName())
: streamRepository.getDeploymentStatus(id.getUnitName());
metadata = new ModuleMetadata(id,
getResolvedModuleOptions(metadataMap),
getDeploymentProperties(moduleDeploymentPath),
status.getState());
}
}
catch (Exception e) {
// NoNodeException - this node does not exist, will return null
ZooKeeperUtils.wrapAndThrowIgnoring(e, NoNodeException.class);
}
return metadata;
}
/**
* Get the deployment properties associated with this module metadata path.
*
* @param moduleDeploymentsPath the module deployment path
* @return deployment properties
*/
private Properties getDeploymentProperties(String moduleDeploymentsPath) {
Map<String, String> deploymentProperties = new HashMap<String, String>();
try {
deploymentProperties = ZooKeeperUtils.bytesToMap(zkConnection.getClient().getData()
.forPath(moduleDeploymentsPath));
}
catch (Exception e) {
ZooKeeperUtils.wrapAndThrowIgnoring(e, NoNodeException.class);
}
return MapUtils.toProperties(deploymentProperties);
}
/**
* Resolve the module option value using the module metadata.
*
* @param metadataMap the values map from ZK module metadata
* @return the resolved option values
*/
private Properties getResolvedModuleOptions(Map<String, String> metadataMap) {
Map<String, String> optionsMap = new HashMap<String, String>();
for (String propertyKey : metadataMap.keySet()) {
String propertyValue = metadataMap.get(propertyKey);
if (!propertyKey.startsWith(XD_MODULE_PROPERTIES_PREFIX)
&& !StringUtils.isEmpty(propertyValue)) {
if (propertyValue.startsWith(PlaceholderConfigurerSupport.DEFAULT_PLACEHOLDER_PREFIX) &&
propertyValue.endsWith(PlaceholderConfigurerSupport.DEFAULT_PLACEHOLDER_SUFFIX)) {
// For a property ${module.property}, we just extract "module.property" and
// check if the metadataMap has a value for it.
String placeholderKey = propertyValue.substring(2, propertyValue.length() - 1);
if (metadataMap.get(placeholderKey) != null) {
propertyValue = metadataMap.get(placeholderKey);
}
}
optionsMap.put(propertyKey, propertyValue);
}
}
return MapUtils.toProperties(optionsMap);
}
@Override
public boolean exists(ModuleMetadata.Id id) {
try {
return zkConnection.getClient().checkExists()
.forPath(moduleDeploymentPath(id)) != null;
}
catch (Exception e) {
throw ZooKeeperUtils.wrapThrowable(e);
}
}
@Override
public List<ModuleMetadata> findAll() {
List<ModuleMetadata> results = new ArrayList<ModuleMetadata>();
try {
for (String containerId : getAvailableContainerIds()) {
List<ModuleMetadata.Id> modules = getDeployedModules(containerId);
for (ModuleMetadata.Id moduleId : modules) {
ModuleMetadata metadata = findOne(moduleId);
if (metadata != null) {
results.add(metadata);
}
}
}
return results;
}
catch (Exception e) {
throw ZooKeeperUtils.wrapThrowable(e);
}
}
/**
* Get all the available containers' ids.
*
* @return the list of all available containers' ids.
*/
private List<String> getAvailableContainerIds() {
try {
return zkConnection.getClient().getChildren().forPath(Paths.CONTAINERS);
}
catch (Exception e) {
throw ZooKeeperUtils.wrapThrowable(e);
}
}
/**
* Find all the modules that are deployed into this container.
*
* @param containerId the containerId
* @return {@link ModuleMetadata} of the modules deployed into this container.
*/
public List<ModuleMetadata> findAllByContainerId(String containerId) {
Assert.hasText(containerId, "containerId is required");
List<ModuleMetadata.Id> deployedModules = getDeployedModules(containerId);
logger.debug("deployedModules: {}", deployedModules);
List<ModuleMetadata> results = new ArrayList<ModuleMetadata>(deployedModules.size());
for (ModuleMetadata.Id moduleId : deployedModules) {
ModuleMetadata metadata = findOne(moduleId);
logger.debug("found metadata: {}", metadata);
if (metadata != null) {
results.add(metadata);
}
}
return results;
}
/**
* Get all the deployed modules by the given containerId.
*
* @param containerId the containerId to filter
* @return the list of moduleIds of the deployed modules.
*/
private List<ModuleMetadata.Id> getDeployedModules(String containerId) {
List<ModuleMetadata.Id> ids = new ArrayList<ModuleMetadata.Id>();
try {
CuratorFramework client = zkConnection.getClient();
if (client.checkExists().forPath(Paths.build(Paths.CONTAINERS, containerId)) != null) {
List<String> qualifiedIds = client.getChildren().forPath(containerAllocationPath(containerId));
for (String qualifiedId : qualifiedIds) {
ids.add(new ModuleMetadata.Id(containerId, qualifiedId));
}
}
}
catch (Exception e) {
ZooKeeperUtils.wrapAndThrowIgnoring(e, NoNodeException.class);
}
return ids;
}
@Override
public Iterable<ModuleMetadata> findAll(Iterable<ModuleMetadata.Id> ids) {
List<ModuleMetadata> results = new ArrayList<ModuleMetadata>();
for (ModuleMetadata.Id id : ids) {
ModuleMetadata entity = findOne(id);
if (entity != null) {
results.add(entity);
}
}
return results;
}
@Override
public Iterable<ModuleMetadata> findAllInRange(ModuleMetadata.Id from,
boolean fromInclusive, ModuleMetadata.Id to, boolean toInclusive) {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public long count() {
long count = 0;
try {
List<String> containerIds = zkConnection.getClient().getChildren().forPath(Paths.MODULE_DEPLOYMENTS);
for (String containerId : containerIds) {
Stat stat = zkConnection.getClient().checkExists().forPath(containerAllocationPath(containerId));
if (stat != null) {
count+= stat.getNumChildren();
}
}
}
catch (Exception e) {
throw ZooKeeperUtils.wrapThrowable(e);
}
return count;
}
/**
* Return the module allocation path for the given container id.
*
* @param id container id
* @return path for module allocations for the container
*/
private String containerAllocationPath(String id) {
return Paths.build(Paths.MODULE_DEPLOYMENTS, Paths.ALLOCATED, id);
}
/**
* Return the module deployment path for the module indicated
* by the provided {@link org.springframework.xd.dirt.module.store.ModuleMetadata.Id}.
*
* @param id id for module instance
* @return path for module allocation
*/
private String moduleDeploymentPath(ModuleMetadata.Id id) {
return Paths.build(Paths.MODULE_DEPLOYMENTS, Paths.ALLOCATED, id.getContainerId(),
id.getFullyQualifiedId());
}
@Override
public <S extends ModuleMetadata> S save(S entity) {
throw new UnsupportedOperationException();
}
@Override
public <S extends ModuleMetadata> Iterable<S> save(Iterable<S> entities) {
throw new UnsupportedOperationException();
}
@Override
public void delete(ModuleMetadata.Id id) {
throw new UnsupportedOperationException();
}
@Override
public void delete(ModuleMetadata entity) {
throw new UnsupportedOperationException();
}
@Override
public void delete(Iterable<? extends ModuleMetadata> entities) {
throw new UnsupportedOperationException();
}
@Override
public void deleteAll() {
throw new UnsupportedOperationException();
}
}