+print "GetNodeGroups",
+nodegroups = GetNodeGroups(admin, nodegroup_ids)
+for nodegroup in nodegroups:
+ assert set(nodegroup['node_ids']) == set(node_ids)
+print "=> OK"
+
+print "GetNetworkMethods",
+network_methods = GetNetworkMethods(admin)
+print "=>", network_methods
+
+print "GetNetworkTypes",
+network_types = GetNetworkTypes(admin)
+print "=>", network_types
+
+# Add node networks
+nodenetwork_ids = []
+for node_id in node_ids:
+ def random_nodenetwork(method, type):
+ nodenetwork_fields = {
+ 'method': method,
+ 'type': type,
+ 'bwlimit': randint(500000, 10000000),
+ }
+
+ if method != 'dhcp':
+ ip = randint(0, 0xffffffff)
+ netmask = (0xffffffff << randint(2, 31)) & 0xffffffff
+ network = ip & netmask
+ broadcast = ((ip & netmask) | ~netmask) & 0xffffffff
+ gateway = randint(network + 1, broadcast - 1)
+ dns1 = randint(0, 0xffffffff)
+
+ for field in 'ip', 'netmask', 'network', 'broadcast', 'gateway', 'dns1':
+ nodenetwork_fields[field] = socket.inet_ntoa(struct.pack('>L', locals()[field]))
+
+ return nodenetwork_fields
+
+ for method in network_methods:
+ for type in network_types:
+ # Add node network
+ print "AddNodeNetwork",
+ nodenetwork_fields = random_nodenetwork(method, type)
+ nodenetwork_id = AddNodeNetwork(admin, node_id, nodenetwork_fields)
+
+ # Should return a unique nodenetwork_id
+ assert nodenetwork_id not in nodenetwork_ids
+ nodenetwork_ids.append(nodenetwork_id)
+ print "=>", nodenetwork_id
+
+ # Check node network
+ print "GetNodeNetworks(%d)" % nodenetwork_id,
+ nodenetwork = GetNodeNetworks(admin, [nodenetwork_id])[0]
+ for field in nodenetwork_fields:
+ assert unicmp(nodenetwork[field], nodenetwork_fields[field])
+ print "=> OK"
+
+ # Update node network
+ nodenetwork_fields = random_nodenetwork(method, type)
+ print "UpdateNodeNetwork(%d)" % nodenetwork_id,
+ UpdateNodeNetwork(admin, nodenetwork_id, nodenetwork_fields)
+ print "=> OK"
+
+ # Check node network again
+ nodenetwork = GetNodeNetworks(admin, [nodenetwork_id])[0]
+ for field in nodenetwork_fields:
+ assert unicmp(nodenetwork[field], nodenetwork_fields[field])
+
+print "GetNodeNetworks",
+nodenetworks = GetNodeNetworks(admin, nodenetwork_ids)
+assert set(nodenetwork_ids) == set([nodenetwork['nodenetwork_id'] for nodenetwork in nodenetworks])
+print "=>", nodenetwork_ids
+
+# Add PCUs
+pcu_ids = []
+for site_id in site_ids:
+ def random_pcu():
+ return {
+ 'hostname': randhostname(),
+ 'ip': socket.inet_ntoa(struct.pack('>L', randint(0, 0xffffffff))),
+ 'protocol': randstr(16),
+ 'username': randstr(254),
+ 'password': randstr(254),
+ 'notes': randstr(254),
+ 'model': randstr(32),
+ }
+
+ # Add PCU
+ pcu_fields = random_pcu()
+ print "AddPCU",
+ pcu_id = AddPCU(admin, site_id, pcu_fields)
+
+ # Should return a unique pcu_id
+ assert pcu_id not in pcu_ids
+ pcu_ids.append(pcu_id)
+ print "=>", pcu_id
+
+ # Check PCU
+ print "GetPCUs(%d)" % pcu_id,
+ pcu = GetPCUs(admin, [pcu_id])[0]
+ for field in pcu_fields:
+ assert unicmp(pcu[field], pcu_fields[field])
+ print "=> OK"
+
+ # Update PCU
+ pcu_fields = random_pcu()
+ print "UpdatePCU(%d)" % pcu_id,
+ UpdatePCU(admin, pcu_id, pcu_fields)
+ print "=> OK"
+
+ # Check PCU again
+ pcu = GetPCUs(admin, [pcu_id])[0]
+ for field in pcu_fields:
+ assert unicmp(pcu[field], pcu_fields[field])
+
+ # Add each node at this site to a different port on this PCU
+ site = GetSites(admin, [site_id])[0]
+ port = randint(1, 10)
+ for node_id in site['node_ids']:
+ print "AddNodeToPCU(%d, %d, %d)" % (node_id, pcu_id, port),
+ AddNodeToPCU(admin, node_id, pcu_id, port)
+ print "=> OK"
+ port += 1
+
+print "GetPCUs",
+pcus = GetPCUs(admin, pcu_ids)
+assert set(pcu_ids) == set([pcu['pcu_id'] for pcu in pcus])
+print "=>", pcu_ids
+
+# Add configuration files
+conf_file_ids = []
+for nodegroup_id in nodegroup_ids:
+ def random_conf_file():
+ return {
+ 'enabled': bool(randint()),
+ 'source': randpath(255),
+ 'dest': randpath(255),
+ 'file_permissions': "%#o" % randint(0, 512),
+ 'file_owner': randstr(32, letters + '_' + digits),
+ 'file_group': randstr(32, letters + '_' + digits),
+ 'preinstall_cmd': randpath(100),
+ 'postinstall_cmd': randpath(100),
+ 'error_cmd': randpath(100),
+ 'ignore_cmd_errors': bool(randint()),
+ 'always_update': bool(randint()),
+ }
+
+ # Add configuration file
+ conf_file_fields = random_conf_file()
+ print "AddConfFile",
+ conf_file_id = AddConfFile(admin, conf_file_fields)
+
+ # Should return a unique conf_file_id
+ assert conf_file_id not in conf_file_ids
+ conf_file_ids.append(conf_file_id)
+ print "=>", conf_file_id
+
+ # Check configuration file
+ print "GetConfFiles(%d)" % conf_file_id,
+ conf_file = GetConfFiles(admin, [conf_file_id])[0]
+ for field in conf_file_fields:
+ assert unicmp(conf_file[field], conf_file_fields[field])
+ print "=> OK"
+
+ # Update configuration file
+ conf_file_fields = random_conf_file()
+ print "UpdateConfFile(%d)" % conf_file_id,
+ UpdateConfFile(admin, conf_file_id, conf_file_fields)
+ print "=> OK"
+
+ # Check configuration file
+ conf_file = GetConfFiles(admin, [conf_file_id])[0]
+ for field in conf_file_fields:
+ assert unicmp(conf_file[field], conf_file_fields[field])
+
+ # Add to all node groups
+ for nodegroup_id in nodegroup_ids:
+ print "AddConfFileToNodeGroup(%d, %d)" % (conf_file_id, nodegroup_id),
+ AddConfFileToNodeGroup(admin, conf_file_id, nodegroup_id)
+ print "=> OK"
+
+ # Add to all nodes
+ for node_id in node_ids:
+ print "AddConfFileToNode(%d, %d)" % (conf_file_id, node_id),
+ AddConfFileToNode(admin, conf_file_id, node_id)
+ print "=> OK"
+
+print "GetConfFiles",
+conf_files = GetConfFiles(admin, conf_file_ids)
+assert set(conf_file_ids) == set([conf_file['conf_file_id'] for conf_file in conf_files])
+for conf_file in conf_files:
+ assert set(nodegroup_ids) == set(conf_file['nodegroup_ids'])
+ assert set(node_ids) == set(conf_file['node_ids'])
+print "=>", conf_file_ids
+
+# Add slice attribute types
+attribute_type_ids = []
+for i in range(3):
+ def random_attribute_type():
+ return {
+ 'name': randstr(100),
+ 'description': randstr(254),
+ 'min_role_id': random.sample(roles.values(), 1)[0],
+ }
+
+ # Add slice attribute type
+ attribute_type_fields = random_attribute_type()
+ print "AddSliceAttributeType",
+ attribute_type_id = AddSliceAttributeType(admin, attribute_type_fields)
+
+ # Should return a unique attribute_type_id
+ assert attribute_type_id not in attribute_type_ids
+ attribute_type_ids.append(attribute_type_id)
+ print "=>", attribute_type_id
+
+ # Check slice attribute type
+ print "GetSliceAttributeTypes(%d)" % attribute_type_id,
+ attribute_type = GetSliceAttributeTypes(admin, [attribute_type_id])[0]
+ for field in attribute_type_fields:
+ assert unicmp(attribute_type[field], attribute_type_fields[field])
+ print "=> OK"
+
+ # Update slice attribute type
+ attribute_type_fields = random_attribute_type()
+ print "UpdateSliceAttributeType(%d)" % attribute_type_id,
+ UpdateSliceAttributeType(admin, attribute_type_id, attribute_type_fields)
+ print "=> OK"
+
+ # Check slice attribute type again
+ attribute_type = GetSliceAttributeTypes(admin, [attribute_type_id])[0]
+ for field in attribute_type_fields:
+ assert unicmp(attribute_type[field], attribute_type_fields[field])
+
+# Add slices and slice attributes
+slice_ids = []
+slice_attribute_ids = []
+for site in sites:
+ for i in range(site['max_slices']):
+ def random_slice():
+ return {
+ 'name': site['login_base'] + "_" + randstr(11, letters).lower(),
+ 'url': "http://" + randhostname() + "/",
+ 'description': randstr(2048),
+ }
+
+ # Add slice
+ slice_fields = random_slice()
+ print "AddSlice",
+ slice_id = AddSlice(admin, slice_fields)
+
+ # Should return a unique slice_id
+ assert slice_id not in slice_ids
+ slice_ids.append(slice_id)
+ print "=>", slice_id
+
+ # Check slice
+ print "GetSlices(%d)" % slice_id,
+ slice = GetSlices(admin, [slice_id])[0]
+ for field in slice_fields:
+ assert unicmp(slice[field], slice_fields[field])
+ print "=> OK"
+
+ # Update slice
+ slice_fields = random_slice()
+ # Cannot change slice name
+ del slice_fields['name']
+ print "UpdateSlice(%d)" % slice_id,
+ UpdateSlice(admin, slice_id, slice_fields)
+ slice = GetSlices(admin, [slice_id])[0]
+ for field in slice_fields:
+ assert unicmp(slice[field], slice_fields[field])
+ print "=> OK"
+
+ # Add slice to all nodes
+ print "AddSliceToNodes(%d, %s)" % (slice_id, str(node_ids)),
+ AddSliceToNodes(admin, slice_id, node_ids)
+ slice = GetSlices(admin, [slice_id])[0]
+ assert set(node_ids) == set(slice['node_ids'])
+ print "=> OK"
+
+ # Add users to slice
+ for person_id in person_ids:
+ print "AddPersonToSlice(%d, %d)" % (person_id, slice_id),
+ AddPersonToSlice(admin, person_id, slice_id)
+ print "=> OK"
+ slice = GetSlices(admin, [slice_id])[0]
+ assert set(person_ids) == set(slice['person_ids'])
+
+ # Set slice/sliver attributes
+ for attribute_type_id in attribute_type_ids:
+ value = randstr(16, letters + '_' + digits)
+ # Make it a sliver attribute with 50% probability
+ node_id = random.sample(node_ids + [None] * len(node_ids), 1)[0]
+
+ # Add slice attribute
+ print "AddSliceAttribute(%d, %d)" % (slice_id, attribute_type_id),
+ if node_id is None:
+ slice_attribute_id = AddSliceAttribute(admin, slice_id, attribute_type_id, value)
+ else:
+ slice_attribute_id = AddSliceAttribute(admin, slice_id, attribute_type_id, value, node_id)
+
+ # Should return a unique slice_attribute_id
+ assert slice_attribute_id not in slice_attribute_ids
+ slice_attribute_ids.append(slice_attribute_id)
+ print "=>", slice_attribute_id
+
+ # Check slice attribute
+ print "GetSliceAttributes(%d)" % slice_attribute_id,
+ slice_attribute = GetSliceAttributes(admin, [slice_attribute_id])[0]
+ for field in 'attribute_type_id', 'slice_id', 'node_id', 'slice_attribute_id', 'value':
+ assert unicmp(slice_attribute[field], locals()[field])
+ print "=> OK"
+
+ # Update slice attribute
+ value = randstr(16, letters + '_' + digits)
+ print "UpdateSliceAttribute(%d)" % slice_attribute_id,
+ UpdateSliceAttribute(admin, slice_attribute_id, value)
+ slice_attribute = GetSliceAttributes(admin, [slice_attribute_id])[0]
+ for field in 'attribute_type_id', 'slice_id', 'node_id', 'slice_attribute_id', 'value':
+ assert unicmp(slice_attribute[field], locals()[field])
+ print "=> OK"
+
+# Delete slices
+for slice_id in slice_ids:
+ # Delete slice attributes
+ slice = GetSlices(admin, [slice_id])[0]
+ for slice_attribute_id in slice['slice_attribute_ids']:
+ print "DeleteSliceAttribute(%d, %d)" % (slice_id, slice_attribute_id),
+ DeleteSliceAttribute(admin, slice_attribute_id)
+ print "=> OK"
+ slice = GetSlices(admin, [slice_id])[0]
+ assert not slice['slice_attribute_ids']
+
+ # Delete users from slice
+ for person_id in person_ids:
+ print "DeletePersonFromSlice(%d, %d)" % (person_id, slice_id),
+ DeletePersonFromSlice(admin, person_id, slice_id)
+ print "=> OK"
+ slice = GetSlices(admin, [slice_id])[0]
+ assert not slice['person_ids']
+
+ # Delete nodes from slice
+ print "DeleteSliceFromNodes(%d, %s)" % (slice_id, node_ids),
+ DeleteSliceFromNodes(admin, slice_id, node_ids)
+ print "=> OK"
+ slice = GetSlices(admin, [slice_id])[0]
+ assert not slice['node_ids']
+
+ # Delete slice
+ print "DeleteSlice(%d)" % slice_id,
+ DeleteSlice(admin, slice_id)
+ assert not GetSlices(admin, [slice_id])
+
+ # Make sure it really deleted it
+ slices = GetSlices(admin, slice_ids)
+ assert slice_id not in [slice['slice_id'] for slice in slices]
+ print "=> OK"
+
+print "GetSlices",
+assert not GetSlices(admin, slice_ids)
+print "=> []"
+
+# Delete slice attribute types
+for attribute_type_id in attribute_type_ids:
+ # Delete slice attribute type
+ print "DeleteSliceAttributeType(%d)" % attribute_type_id,
+ DeleteSliceAttributeType(admin, attribute_type_id)
+ assert not GetSliceAttributeTypes(admin, [attribute_type_id])
+
+ # Make sure it really deleted it
+ attribute_types = GetSliceAttributeTypes(admin, attribute_type_ids)
+ assert attribute_type_id not in [attribute_type['attribute_type_id'] for attribute_type in attribute_types]
+ print "=> OK"
+
+print "GetSliceAttributeTypes",
+assert not GetSliceAttributeTypes(admin, attribute_type_ids)
+print "=> []"
+
+# Delete configuration files
+for conf_file in conf_files:
+ conf_file_id = conf_file['conf_file_id']
+
+ for node_id in conf_file['node_ids']:
+ print "DeleteConfFileFromNode(%d, %d)" % (conf_file_id, node_id),
+ DeleteConfFileFromNode(admin, conf_file_id, node_id)
+ print "=> OK"
+
+ for nodegroup_id in conf_file['nodegroup_ids']:
+ print "DeleteConfFileFromNodeGroup(%d, %d)" % (conf_file_id, nodegroup_id),
+ DeleteConfFileFromNodeGroup(admin, conf_file_id, nodegroup_id)
+ print "=> OK"
+
+ print "DeleteConfFile(%d)" % conf_file_id,
+ DeleteConfFile(admin, conf_file_id)
+ print "=> OK"
+
+print "GetConfFiles",
+assert not GetConfFiles(admin, conf_file_ids)
+print "=> []"
+
+# Delete PCUs
+for pcu in pcus:
+ pcu_id = pcu['pcu_id']
+
+ for node_id in pcu['node_ids']:
+ print "DeleteNodeFromPCU(%d, %d)" % (node_id, pcu_id),
+ DeleteNodeFromPCU(admin, node_id, pcu_id)
+ print "=> OK"
+
+ print "DeletePCU(%d)" % pcu_id,
+ DeletePCU(admin, pcu_id)
+ print "=> OK"
+
+print "GetPCUs",
+assert not GetPCUs(admin, pcu_ids)
+print "=> []"
+
+# Delete node networks
+for nodenetwork_id in nodenetwork_ids:
+ print "DeleteNodeNetwork(%d)" % nodenetwork_id,
+ DeleteNodeNetwork(admin, nodenetwork_id)
+ print "=>", "OK"
+
+print "GetNodeNetworks",
+assert not GetNodeNetworks(admin, nodenetwork_ids)
+print "=> []"
+