/*
* 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.server;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;
import org.springframework.xd.dirt.core.DeploymentUnit;
import org.springframework.xd.dirt.core.DeploymentUnitStatus;
import org.springframework.xd.module.ModuleDeploymentProperties;
import org.springframework.xd.module.ModuleDescriptor;
/**
* Default {@link org.springframework.xd.dirt.server.DeploymentUnitStateCalculator}
* implementation for streams and jobs. This implementation uses the following
* criteria:
* <ul>
* <li>If all expected modules are deployed, the state is considered
* {@link org.springframework.xd.dirt.core.DeploymentUnitStatus.State#deployed deployed}.</li>
* <li>If one or more of the modules do not have the number of expected
* instances but there is at least one instance of each module,
* the state is considered
* {@link org.springframework.xd.dirt.core.DeploymentUnitStatus.State#incomplete incomplete}.</li>
* <li>If one or more of the modules do not have any instances deployed,
* the state is considered
* {@link org.springframework.xd.dirt.core.DeploymentUnitStatus.State#failed failed}.</li>
* </ul>
*
* @author Patrick Peralta
*/
public class DefaultStateCalculator implements DeploymentUnitStateCalculator {
/**
* Logger.
*/
private static final Logger logger = LoggerFactory.getLogger(DefaultStateCalculator.class);
/**
* {@inheritDoc}
*/
@Override
public DeploymentUnitStatus calculate(DeploymentUnit deploymentUnit,
ModuleDeploymentPropertiesProvider<ModuleDeploymentProperties> provider,
Collection<ModuleDeploymentStatus> deploymentStatuses) {
Map<ModuleDescriptor.Key, Count> moduleCount = new HashMap<ModuleDescriptor.Key, Count>();
for (ModuleDescriptor descriptor : deploymentUnit.getModuleDescriptors()) {
moduleCount.put(descriptor.createKey(),
new Count(provider.propertiesForDescriptor(descriptor).getCount()));
}
StringBuilder builder = new StringBuilder();
logger.debug("Evaluating state for {}", deploymentUnit.getName());
logger.trace("moduleCountMap: {}", moduleCount);
for (ModuleDeploymentStatus deploymentStatus : deploymentStatuses) {
logger.trace("\t{}", deploymentStatus);
if (deploymentStatus.getState() == ModuleDeploymentStatus.State.deployed) {
ModuleDescriptor.Key key = deploymentStatus.getKey();
Count count = moduleCount.get(key);
if (count != null && (count.expected == 0 || ++count.actual == count.expected)) {
moduleCount.remove(key);
}
}
else if (StringUtils.hasText(deploymentStatus.getErrorDescription())) {
if (builder.length() > 0) {
builder.append("; ");
}
builder.append(deploymentStatus.getErrorDescription());
}
}
logger.trace("moduleCountMap after evaluation: {}", moduleCount);
if (moduleCount.isEmpty()) {
return new DeploymentUnitStatus(DeploymentUnitStatus.State.deployed, builder.toString());
}
// since there are some modules that did not meet the expected count,
// iterate the map and determine if any modules failed to deploy at all;
// if each module type has at least one deployment the status is considered
// incomplete
boolean failed = false;
for (Count count : moduleCount.values()) {
if (count.actual == 0) {
failed = true;
break;
}
}
DeploymentUnitStatus.State state = (failed)
? DeploymentUnitStatus.State.failed
: DeploymentUnitStatus.State.incomplete;
return new DeploymentUnitStatus(state, builder.toString());
}
/**
* Structure to track the number of expected and actual module deployments.
*/
private static class Count {
/**
* The number of expected module instances.
*/
final int expected;
/**
* The number of actual module instances.
*/
int actual;
/**
* Construct a {@code Count} with the expected module count.
*
* @param expected expected number of modules
*/
private Count(int expected) {
this.expected = expected;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return "Count{" +
"expected=" + expected +
", actual=" + actual +
'}';
}
}
}