Stack getStack(final ExternalEvent event) {
final Map<String, Object> env =
CollectionUtils.castMap(DataUtils.getFields(event).get(FIELD_ENVIRIONMENT));
Object eId = CollectionUtils.getNestedValue(env, FIELD_EXTERNAL_ID);
if (eId == null) {
return null;
}
final String envExtId = eId.toString();
Stack stack = stackDao.getStackByExternalId(event.getAccountId(), envExtId);
// If stack has not been created yet
if (stack == null) {
final Stack newEnv = objectManager.newRecord(Stack.class);
Object possibleName = CollectionUtils.getNestedValue(env, "name");
newEnv.setExternalId(envExtId);
newEnv.setAccountId(event.getAccountId());
String name = possibleName != null ? possibleName.toString() : envExtId;
newEnv.setName(name);
stack =
DeferredUtils.nest(
new Callable<Stack>() {
@Override
public Stack call() {
return resourceDao.createAndSchedule(newEnv);
}
});
stack =
resourceMonitor.waitFor(
stack,
new ResourcePredicate<Stack>() {
@Override
public boolean evaluate(Stack obj) {
return obj != null && CommonStatesConstants.ACTIVE.equals(obj.getState());
}
@Override
public String getMessage() {
return "active state";
}
});
}
return stack;
}
protected void waitForHealthyState(Service service) {
List<? extends Instance> serviceInstances =
exposeMapDao.listServiceManagedInstances(service.getId());
final List<String> healthyStates =
Arrays.asList(
HealthcheckConstants.HEALTH_STATE_HEALTHY,
HealthcheckConstants.HEALTH_STATE_UPDATING_HEALTHY);
for (final Instance instance : serviceInstances) {
resourceMntr.waitFor(
instance,
DEFAULT_WAIT_TIMEOUT,
new ResourcePredicate<Instance>() {
@Override
public boolean evaluate(Instance obj) {
return instance.getHealthState() == null
|| healthyStates.contains(obj.getHealthState());
}
});
}
}
protected Subnet getServiceVipSubnet(final Service service) {
Subnet vipSubnet =
DeferredUtils.nest(
new Callable<Subnet>() {
@Override
public Subnet call() throws Exception {
return ntwkDao.addVIPSubnet(service.getAccountId());
}
});
// wait for subnet to become active so the ip range is populated
vipSubnet =
resourceMonitor.waitFor(
vipSubnet,
new ResourcePredicate<Subnet>() {
@Override
public boolean evaluate(Subnet obj) {
return CommonStatesConstants.ACTIVE.equals(obj.getState());
}
});
return vipSubnet;
}
protected void stopInstances(Map<String, List<Instance>> deploymentUnitInstancesToStop) {
List<Instance> toStop = new ArrayList<>();
for (String key : deploymentUnitInstancesToStop.keySet()) {
toStop.addAll(deploymentUnitInstancesToStop.get(key));
}
for (Instance instance : toStop) {
if (!instance.getState().equalsIgnoreCase(InstanceConstants.STATE_STOPPED)) {
objectProcessMgr.scheduleProcessInstanceAsync(
InstanceConstants.PROCESS_STOP, instance, null);
}
}
for (Instance instance : toStop) {
resourceMntr.waitFor(
instance,
new ResourcePredicate<Instance>() {
@Override
public boolean evaluate(Instance obj) {
return InstanceConstants.STATE_STOPPED.equals(obj.getState());
}
});
}
}
public void cleanupUpgradedInstances(Service service) {
List<? extends ServiceExposeMap> maps = exposeMapDao.getInstancesSetForUpgrade(service.getId());
List<Instance> waitList = new ArrayList<>();
for (ServiceExposeMap map : maps) {
Instance instance = objectManager.loadResource(Instance.class, map.getInstanceId());
if (instance == null
|| instance.getState().equals(CommonStatesConstants.REMOVED)
|| instance.getState().equals(CommonStatesConstants.REMOVING)) {
continue;
}
try {
objectProcessMgr.scheduleProcessInstanceAsync(
InstanceConstants.PROCESS_REMOVE, instance, null);
} catch (ProcessCancelException ex) {
// in case instance was manually restarted
objectProcessMgr.scheduleProcessInstanceAsync(
InstanceConstants.PROCESS_STOP,
instance,
ProcessUtils.chainInData(
new HashMap<String, Object>(),
InstanceConstants.PROCESS_STOP,
InstanceConstants.PROCESS_REMOVE));
}
}
for (Instance instance : waitList) {
resourceMntr.waitFor(
instance,
new ResourcePredicate<Instance>() {
@Override
public boolean evaluate(Instance obj) {
return CommonStatesConstants.REMOVED.equals(obj.getState());
}
});
}
}