public static boolean recursivelyLocked(ResourceTreeNode node) {
if (node.getData() instanceof ResourceFlyweight
&& !((ResourceFlyweight) node.getData()).isLocked()) {
return false;
}
boolean allLocked = true;
for (ResourceTreeNode child : node.getChildren()) {
if (!recursivelyLocked(child)) allLocked = false;
}
return allLocked;
}
public static void load(ResourceTreeNode parentNode) {
if (parentNode.getData() instanceof ResourceFlyweight) {
ResourceFlyweight parentResource = (ResourceFlyweight) parentNode.getData();
Map<Object, List<ResourceFlyweight>> children =
new HashMap<Object, List<ResourceFlyweight>>();
for (ResourceFlyweight res : parentResource.getChildResources()) {
if (res.getResourceType().getSubCategory() != null) {
// These are children that have subcategories
// Split them by if they are a sub-sub category or just a category
ResourceSubCategoryFlyweight categoryKey =
res.getResourceType().getSubCategory().getParentSubCategory();
if (categoryKey == null) {
categoryKey = res.getResourceType().getSubCategory();
}
addToList(children, categoryKey, res);
} else {
// These are children without categories of the parent resource
// - Add them into groupings by their resource type
addToList(children, res.getResourceType(), res);
}
}
Set<String> dupResourceTypeNames = getDuplicateResourceTypeNames(children);
for (Map.Entry<Object, List<ResourceFlyweight>> entry : children.entrySet()) {
Object key = entry.getKey();
List<ResourceFlyweight> resources = entry.getValue();
double avail = 0;
for (ResourceFlyweight res : resources) {
avail +=
res.getCurrentAvailability().getAvailabilityType() == AvailabilityType.UP ? 1 : 0;
}
avail = avail / resources.size();
Object nodeData = null;
if (key instanceof ResourceSubCategoryFlyweight) {
nodeData =
new AutoGroupCompositeFlyweight(
avail, parentResource, (ResourceSubCategoryFlyweight) key, resources.size());
} else if (key instanceof ResourceTypeFlyweight) {
ResourceTypeFlyweight typeKey = (ResourceTypeFlyweight) key;
if (typeKey.isSingleton()) {
nodeData = resources.get(0);
} else {
boolean isDupResourceTypeName = dupResourceTypeNames.contains(typeKey.getName());
nodeData =
new AutoGroupCompositeFlyweight(
avail, parentResource, typeKey, resources.size(), isDupResourceTypeName);
}
}
ResourceTreeNode node = new ResourceTreeNode(nodeData, parentNode);
load(node);
if (!recursivelyLocked(node)) {
parentNode.getChildren().add(node);
}
}
} else {
// #####################################################################################
AutoGroupCompositeFlyweight compositeParent =
(AutoGroupCompositeFlyweight) parentNode.getData();
Map<Object, List<ResourceFlyweight>> children =
new HashMap<Object, List<ResourceFlyweight>>();
log.debug("composite parent" + compositeParent);
if (compositeParent != null) {
MembersCategoryHint membersCategory = MembersCategoryHint.NONE;
MembersAvailabilityHint membersAvailabilityHint = MembersAvailabilityHint.UP;
for (ResourceFlyweight res : compositeParent.getParentResource().getChildResources()) {
boolean process = false;
if (compositeParent.getSubcategory() != null) {
// parent is a sub category
if (res.getResourceType().getSubCategory() != null
&& compositeParent
.getSubcategory()
.equals(res.getResourceType().getSubCategory().getParentSubCategory())
&& compositeParent.getParentResource().equals(res.getParentResource())) {
// A subSubCategory in a subcategory
addToList(children, res.getResourceType().getSubCategory(), res);
process = true;
} else if (compositeParent
.getSubcategory()
.equals(res.getResourceType().getSubCategory())
&& compositeParent.getParentResource().equals(res.getParentResource())) {
// Direct entries in a subcategory... now group them by autogroup (type)
addToList(children, res.getResourceType(), res);
process = true;
}
} else if (compositeParent.getResourceType() != null) {
if (compositeParent.getResourceType().equals(res.getResourceType())
&& compositeParent.getParentResource().getId() == res.getParentResource().getId()) {
addToList(children, res.getResourceType(), res);
process = true;
}
}
if (process) {
// amend the overall category of all the members of the auto group.
switch (membersCategory) {
case NONE: // this is the first child, so let's use its category as a starting point
membersCategory =
MembersCategoryHint.fromResourceCategory(res.getResourceType().getCategory());
break;
case MIXED: // this is the "final" state. The children type is not going to change
// from this.
break;
default: // check if this child has the same category as its previous siblings.
if (MembersCategoryHint.fromResourceCategory(res.getResourceType().getCategory())
!= membersCategory) {
membersCategory = MembersCategoryHint.MIXED;
}
}
// amend the availability hint of the autogroup. If all resources are up, the hint is
// UP, if some of the resources
// are down, the hint is DOWN, if some of the resources' avail state is unknown, the
// hint is UNKNOWN.
// The down state has the highest priority.
switch (membersAvailabilityHint) {
case UP:
membersAvailabilityHint =
MembersAvailabilityHint.fromAvailabilityType(
res.getCurrentAvailability().getAvailabilityType());
break;
case UNKNOWN:
if (res.getCurrentAvailability().getAvailabilityType() == AvailabilityType.DOWN) {
membersAvailabilityHint = MembersAvailabilityHint.DOWN;
}
break;
case DOWN:; // a "terminal" state... if some resource is down, the overall state is
// going to be down as that is the most important information.
}
}
}
compositeParent.setMembersCategoryHint(membersCategory);
compositeParent.setMembersAvailabilityHint(membersAvailabilityHint);
}
AutoGroupCompositeFlyweight compositeParentNode =
(AutoGroupCompositeFlyweight) parentNode.getData();
for (Map.Entry<Object, List<ResourceFlyweight>> entry : children.entrySet()) {
Object key = entry.getKey();
List<ResourceFlyweight> resources = entry.getValue();
if (compositeParentNode.getSubcategory() != null) {
double avail = 0;
for (ResourceFlyweight res : resources) {
avail +=
res.getCurrentAvailability().getAvailabilityType() == AvailabilityType.UP ? 1 : 0;
}
avail = avail / resources.size();
Object nodeData = null;
if (key instanceof ResourceSubCategoryFlyweight) {
nodeData =
new AutoGroupCompositeFlyweight(
avail,
compositeParent.getParentResource(),
(ResourceSubCategoryFlyweight) key,
resources.size());
} else if (key instanceof ResourceTypeFlyweight) {
ResourceTypeFlyweight typeKey = (ResourceTypeFlyweight) key;
if (typeKey.isSingleton()) {
nodeData = resources.get(0);
} else {
nodeData =
new AutoGroupCompositeFlyweight(
avail, compositeParent.getParentResource(), typeKey, resources.size(), false);
}
}
ResourceTreeNode node = new ResourceTreeNode(nodeData, parentNode);
load(node);
if (!recursivelyLocked(node)) {
parentNode.getChildren().add(node);
}
} else {
for (ResourceFlyweight res : resources) {
ResourceTreeNode node = new ResourceTreeNode(res, parentNode);
load(node);
if (!recursivelyLocked(node)) {
parentNode.getChildren().add(node);
}
}
}
}
}
}
