def buildNeblockTrees(self):
tmpArray = []
allObjects = self.levelDisplayObjects;
allEffectiveObjects = {};
self.loadBalancerLineIndex = -1;
self.instanceLineIndex = -1;
self.volumeLineIndex = -1;
self.gridColCount = 0
self.gridLineCount = 0
for aFilter in self.filterArray:
if aFilter.has_key('vpc_id'):
self.vpcuuid = aFilter['vpc_id'];
tmpVPC = self.levelDisplayObjects[self.vpcuuid];
modelLogicalRootNode = nep_tree_logical.nepLogicalNode(self.logicalRootUUID);
tmpArray.append(modelLogicalRootNode);
for idx in range(len(self.levelDisplayIdentifiers) -1):
for anObjectUUID in self.levelDisplayObjects.keys():
anObject = self.levelDisplayObjects[anObjectUUID];
if anObject['__class_name'] == 'connection':
continue
if False == anObject.has_key("logical_level"):
continue;
if anObject["logical_level"] == idx:
aNode = nep_tree_logical.nepLogicalNode(anObjectUUID)
if anObject['__class_name'] == 'zone':
if anObject['region'] == tmpVPC['region']:
modelLogicalRootNode.addChild(aNode)
elif anObject['__class_name'] == 'subnet':
for pNode in tmpArray:
if anObject.has_key('zones') and len(anObject['zones']) > 0:
if pNode.representedObject == anObject['zones'][0]:
pNode.addChild(aNode);
break;
elif anObject['__class_name'] == 'volume' or anObject['__class_name'] == 'load_balancer' or anObject['__class_name'] == 'instance' or anObject['__class_name'] == 'database':
if '.ec2classic' in self.vpcuuid:
for pNode in tmpArray:
pass #TOTO implement stuff
else:
for pNode in tmpArray:
if pNode.representedObject == self.levelDisplayObjects[anObjectUUID]["subnet_id"]:
pNode.addChild(aNode)
tmpArray.append(aNode)
self.modelLogicalRootNode = modelLogicalRootNode
def buildTrees(self, vpcID = 'vpc.all', filter = None):
"""
Build both the logical and graphical tree for a given VPC and filter. Pass vpc.all for all
information with no VPC and vpc.classic for the "No VPC" part
"""
#TODO add code to delete the tree if it already exists as well as the self.modelGraphItemsDatabase
print "buildTrees"
print vpcID
objectsToUse = None
if vpcID == 'vpc.all':
#compute without taking in account VPC
objectsToUse = self.levelDisplayObjects
tmpArray = []
modelLogicalRootNode = nep_tree_logical.nepLogicalNode(self.logicalRootUUID);
for idx in range(len(self.levelDisplayIdentifiers)):
for anObjectUUID in self.levelDisplayObjects.keys():
if self.levelDisplayObjects[anObjectUUID].has_key('logical_level'):
# print anObjectUUID+ " " + str(self.levelDisplayObjects[anObjectUUID]["logical_level"])
if self.levelDisplayObjects[anObjectUUID]["logical_level"] == idx:
aNode = nep_tree_logical.nepLogicalNode(anObjectUUID)
if self.levelDisplayObjects[anObjectUUID].has_key('logical_parent') == False:
modelLogicalRootNode.addChild(aNode)
else:
for oneNode in tmpArray:
if oneNode.representedObject == self.levelDisplayObjects[anObjectUUID]['logical_parent']:
oneNode.addChild(aNode)
tmpArray.append(aNode)
self.modelLogicalRootNode = modelLogicalRootNode
elif vpcID == 'vpc.classic':
#TODO all in the "non vpc land"
self.modelLogicalRootNode = None
else:
#TODO all in the "non vpc land"
self.modelLogicalRootNode = None
# Now we build the graphical tree
if self.modelLogicalRootNode != None:
self.modelGraphItemsDatabase["root:"+self.logicalRootUUID] = nep_tree_graphical.nepGraphicalNode("root:"+self.logicalRootUUID,-1);
self.modelGraphicalRootNode = self.modelGraphItemsDatabase["root:"+self.logicalRootUUID]
# this help does the full job of linking a graph parent to a child, creating the items
# and putting the links
def _helperEstablishRelationShipParentToChild(graphParentUUID,graphChildUUID):
if False == self.modelGraphItemsDatabase.has_key(graphParentUUID):
self.modelGraphItemsDatabase[graphParentUUID] = nep_tree_graphical.nepGraphicalNode(graphParentUUID,0)
if False == self.modelGraphItemsDatabase.has_key(graphChildUUID):
self.modelGraphItemsDatabase[graphChildUUID] = nep_tree_graphical.nepGraphicalNode(graphChildUUID,0)
parentItem = self.modelGraphItemsDatabase[graphParentUUID]
childItem =self.modelGraphItemsDatabase[graphChildUUID]
graphlinkUUUID = "link::"+graphParentUUID+"::"+graphChildUUID
if False == self.modelGraphItemsDatabase.has_key(graphlinkUUUID):
self.modelGraphItemsDatabase[graphlinkUUUID] = nep_tree_graphical.nepGraphicalNode(graphlinkUUUID,0)
linkItem = self.modelGraphItemsDatabase[graphlinkUUUID]
linkItem.graphItemLevel = parentItem.graphItemLevel+0.5
childItem.graphItemLevel = parentItem.graphItemLevel+1.0
parentItem.addSubUUID(graphChildUUID)
parentItem.addLinkUUID(graphlinkUUUID)
childItem.addSuperUUID(graphParentUUID)
childItem.addLinkUUID(graphlinkUUUID)
linkItem.addNodeUUID(graphChildUUID)
linkItem.addNodeUUID(graphParentUUID)
# this is the call back used to build the graphical tree when parsing/traversing the logical
def _buildGraphTreeForNode(node):
graphicalUUID = ("root:"+node.representedObject) if (node == modelLogicalRootNode) else ("item:"+node.representedObject)
subLevelRepartition = {};
for aLogicalChildNode in node.childrenNodes:
tmpIndex = self.levelDisplayObjects[aLogicalChildNode.representedObject]['logical_level']
if False == subLevelRepartition.has_key(tmpIndex):
subLevelRepartition[tmpIndex] = []
subLevelRepartition[tmpIndex].append(aLogicalChildNode.representedObject)
for aLevelKey in subLevelRepartition.keys():
levelElements = subLevelRepartition[aLevelKey]
if 1 == len(levelElements):
childItemGraphicalUUID = "item:"+levelElements[0];
_helperEstablishRelationShipParentToChild(graphicalUUID, childItemGraphicalUUID)
else:
childGroupGraphicalUUID = "group:"+node.representedObject+":"+str(aLevelKey)
_helperEstablishRelationShipParentToChild(graphicalUUID, childGroupGraphicalUUID)
childMultiGraphicalUUID = "multi:"+node.representedObject+":"+str(aLevelKey)
_helperEstablishRelationShipParentToChild(graphicalUUID, childMultiGraphicalUUID)
for anLevelElement in levelElements:
subChildGRaphUUID = "item:"+anLevelElement;
_helperEstablishRelationShipParentToChild(childGroupGraphicalUUID, subChildGRaphUUID);
_helperEstablishRelationShipParentToChild(childMultiGraphicalUUID, subChildGRaphUUID);
#build the graphical tree
self.modelLogicalRootNode.trasverse(_buildGraphTreeForNode)