def test_w_interfaces_configured_in_both_groups_same_net(self): self.group.set_net_to_if('eth0', self.network11.name) self.new_group1.set_net_to_if('eth0', self.network11.name) self.node = luna.Node(name=self.node.name, mongo_db=self.db) self.assertTrue(self.node.set_group(self.new_group1.name)) self.node = luna.Node(name=self.node.name, mongo_db=self.db) self.group = luna.Group(name=self.group.name, mongo_db=self.db) self.new_group1 = luna.Group(name=self.new_group1.name, mongo_db=self.db) self.network11 = luna.Network(name=self.network11.name, mongo_db=self.db) group_if_uid = None for uuid in self.new_group1._json['interfaces']: group_if_uid = uuid self.assertEqual(self.node._json['interfaces'][group_if_uid], { '4': 1, '6': None }) self.assertEqual(self.network11._json['freelist'], [{ 'start': 2, 'end': 65533 }])
def test_wo_interfaces_configured(self): self.assertTrue(self.node.set_group(self.new_group1.name)) self.node = luna.Node(name=self.node.name, mongo_db=self.db) self.group = luna.Group(name=self.group.name, mongo_db=self.db) self.new_group1 = luna.Group(name=self.new_group1.name, mongo_db=self.db) self.assertEqual(self.node._json['group'], self.new_group1.DBRef) self.assertEqual(self.node._json['_use_']['group'], {str(self.new_group1._id): 1}) group_if_uid = None for uuid in self.new_group1._json['interfaces']: group_if_uid = uuid self.assertEqual(self.node._json['interfaces'][group_if_uid], { '4': None, '6': None }) self.assertEqual(self.group._json['_usedby_'], {})
def test_w_interfaces_configured_in_new_group_net6(self): self.node = luna.Node(name=self.node.name, mongo_db=self.db) self.new_group1.set_net_to_if('eth0', self.network61.name) self.assertTrue(self.node.set_group(self.new_group1.name)) self.node = luna.Node(name=self.node.name, mongo_db=self.db) self.group = luna.Group(name=self.group.name, mongo_db=self.db) self.new_group1 = luna.Group(name=self.new_group1.name, mongo_db=self.db) self.network61 = luna.Network(name=self.network61.name, mongo_db=self.db) group_if_uid = None for uuid in self.new_group1._json['interfaces']: group_if_uid = uuid self.assertEqual(self.node._json['interfaces'][group_if_uid], { '4': None, '6': 1 }) self.assertEqual(self.network61._json['freelist'], [{ 'start': 2, 'end': 18446744073709551613 }])
def setUp( self, mock_rpm_addmacro, mock_rpm_transactionset, ): print packages = [ { 'VERSION': '3.10', 'RELEASE': '999-el0', 'ARCH': 'x86_64' }, ] mock_rpm_transactionset.return_value.dbMatch.return_value = packages self.sandbox = Sandbox() self.db = self.sandbox.db self.path = self.sandbox.path self.cluster = luna.Cluster(mongo_db=self.db, create=True, path=self.path, user=getpass.getuser()) self.osimage = luna.OsImage(name='testosimage', path=self.path, mongo_db=self.db, create=True) self.group = luna.Group(name='testgroup', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True) self.new_group1 = luna.Group(name='new1', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True) self.node = luna.Node(group=self.group.name, mongo_db=self.db, create=True) self.network11 = luna.Network(name="net11", mongo_db=self.db, create=True, NETWORK='10.51.0.0', PREFIX=16) self.network61 = luna.Network(name="net61", mongo_db=self.db, create=True, NETWORK='fe80::', PREFIX=64, version=6)
def test_same_ifs_different_nets(self): self.new_group2 = luna.Group(name='new2', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True) self.network12 = luna.Network(name="net12", mongo_db=self.db, create=True, NETWORK='10.52.0.0', PREFIX=16) self.group.set_net_to_if('eth0', self.network11.name) self.new_group2.set_net_to_if('eth0', self.network12.name) self.node = luna.Node(name=self.node.name, mongo_db=self.db) self.node.set_ip(interface_name='eth0', ip='10.51.0.2') self.assertTrue(self.node.set_group(self.new_group2.name)) self.node = luna.Node(name=self.node.name, mongo_db=self.db) self.group = luna.Group(name=self.group.name, mongo_db=self.db) self.new_group2 = luna.Group(name=self.new_group2.name, mongo_db=self.db) self.network11 = luna.Network(name=self.network11.name, mongo_db=self.db) self.network12 = luna.Network(name=self.network12.name, mongo_db=self.db) group_if_uid = None for uuid in self.new_group2._json['interfaces']: group_if_uid = uuid self.assertEqual(self.node._json['interfaces'][group_if_uid], { '4': 1, '6': None }) self.assertEqual(self.network11._json['freelist'], [{ 'start': 1, 'end': 65533 }]) self.assertEqual(self.network12._json['freelist'], [{ 'start': 2, 'end': 65533 }])
def setUp( self, mock_rpm_addmacro, mock_rpm_transactionset, ): packages = [ { 'VERSION': '3.10', 'RELEASE': '999-el0', 'ARCH': 'x86_64' }, ] mock_rpm_transactionset.return_value.dbMatch.return_value = packages print self.sandbox = Sandbox() self.db = self.sandbox.db self.path = self.sandbox.path self.cluster = luna.Cluster(mongo_db=self.db, create=True, path=self.path, user=getpass.getuser()) self.cluster.set('path', self.path) self.osimage = luna.OsImage(name='testosimage', path=self.path, mongo_db=self.db, create=True) self.group = luna.Group( name='testgroup', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True, ) self.group_new = luna.Group( name='testgroup_new', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True, ) self.node = luna.Node( group=self.group.name, mongo_db=self.db, create=True, )
def luna_inventory(self): osimage_suffix = ".osimages.luna" group_suffix = ".groups.luna" inventory = {} inventory['_meta'] = { 'hostvars': {}} osimages = {'hosts':[],'vars': {'ansible_connection': 'lchroot' }} for osimage in luna.list('osimage'): #osimages['hosts'].append(luna.OsImage(osimage).get('path')) osimages['hosts'].append(osimage + osimage_suffix) osimage_path = luna.OsImage(osimage).get('path') inventory['_meta']['hostvars'][osimage + osimage_suffix]= { 'ansible_host': osimage, } inventory['osimages.luna'] = osimages nodes = {} inventory['groups.luna'] = {'hosts': []} for g in luna.list('group'): group = luna.Group(g) hosts = [] nodes = group.list_nodes() for node_name in nodes: node = luna.Node(node_name) hosts.append(node_name) inventory['_meta']['hostvars'][node.show()['name']]={ "bmc_ip":node.get_ip('BMC',version=4)} inventory[g + group_suffix] = {'hosts': hosts} inventory['groups.luna']['hosts'].extend(hosts) return inventory
def test_add_net_group_net4_node_net6(self): if self.sandbox.dbtype != 'mongo': raise unittest.SkipTest( 'This test can be run only with MondoDB as a backend.') self.node.delete() self.group = luna.Group(name=self.group.name, mongo_db=self.db) self.group.set_net_to_if('eth0', self.network.name) self.node = luna.Node( group=self.group.name, mongo_db=self.db, create=True, ) for key in self.node._json['interfaces']: if_dict = self.node._json['interfaces'][key] self.assertEqual(if_dict, {'4': 1, '6': None}) self.group.set_net_to_if('eth0', self.network6.name) self.node = luna.Node(name=self.node.name, mongo_db=self.db) for key in self.node._json['interfaces']: if_dict = self.node._json['interfaces'][key] self.assertEqual(if_dict, {'4': 1, '6': 1})
def luna_group_absent(data): name = data['name'] try: group = luna.Group(name=name) except RuntimeError: return False, False, name return not group.delete(), True, name
def test_wo_nodes(self): if self.sandbox.dbtype != 'mongo': raise unittest.SkipTest( 'This test can be run only with MongoDB as a backend.') self.group.set_net_to_if('eth0', self.network.name) self.node.delete() self.group = luna.Group(name=self.group.name, mongo_db=self.db) self.assertEqual(self.group.get_macs(self.network), {})
def test_delete_group(self): if self.sandbox.dbtype != 'mongo': raise unittest.SkipTest( 'This test can be run only with MondoDB as a backend.') group = luna.Group(name='testgroup', osimage=str(self.osimage.name), mongo_db=self.db, interfaces=['eth0'], create=True) groupid = group._id group.delete() doc = self.db['group'].find_one({'_id': groupid}) self.assertIsNone(doc)
def test_create_group_with_defaults(self): group = luna.Group(name='testgroup1', osimage=str(self.osimage.name), mongo_db=self.db, interfaces=['BOOTIF'], create=True) doc = self.db['group'].find_one({'_id': group._id}) expected = { 'torrent_if': None, 'partscript': 'mount -t tmpfs tmpfs /sysroot', 'postscript': ('cat << EOF >> /sysroot/etc/fstab\n' + 'tmpfs / tmpfs defaults 0 0\n' + 'EOF'), 'name': 'testgroup1', 'bmcsetup': None, 'domain': None, '_use_': { 'cluster': { str(self.cluster._id): 1 }, 'osimage': { str(self.osimage._id): 1 } }, 'osimage': self.osimage.DBRef, 'comment': '' } for attr in expected: self.assertEqual(doc[attr], expected[attr]) # check interfaces if_dict = doc['interfaces'] self.assertEqual(len(if_dict), 1) for uuid in if_dict: self.assertEqual(if_dict[uuid]['name'], 'BOOTIF') self.assertEqual(if_dict[uuid]['params'], '') self.assertEqual(if_dict[uuid]['network'], {'4': None, '6': None})
def test_create_node_exhausted_ips(self): net = luna.Network( 'net', mongo_db=self.db, create=True, NETWORK='10.50.0.0', PREFIX=16, ) tight_net = luna.Network( 'tight_net', mongo_db=self.db, create=True, NETWORK='10.51.0.0', PREFIX=30, ) self.group.add_interface('eth1') self.group.set_net_to_if('eth0', net.name) self.group.set_net_to_if('eth1', tight_net.name) node = luna.Node( group=self.group.name, mongo_db=self.db, create=True, ) with self.assertRaises(RuntimeError): luna.Node( group=self.group.name, mongo_db=self.db, create=True, ) tight_net = luna.Network(name=tight_net.name, mongo_db=self.db) net = luna.Network(name=net.name, mongo_db=self.db) self.group = luna.Group(name=self.group.name, mongo_db=self.db) self.assertEqual(tight_net._json['freelist'], []) self.assertEqual(net._json['freelist'], [{'start': 2, 'end': 65533}]) self.assertEqual(len(self.group._json['_usedby_']['node']), 1)
def luna_group_present(data): data.pop('state') name = data.pop('name') # perform interface data checking, make sure networks are exist, # interface names are unique, etc. # interfaces = data.pop('interfaces') tmp_interfaces = {} for elem in interfaces: if not 'name' in elem: return True, False, "No name for interface defined" if_name = elem['name'] if if_name in tmp_interfaces.keys(): err_msg = "Duplicate name for interface '{}'".format(if_name) return True, False, err_msg tmp_interfaces[if_name] = {} if 'params' in elem: tmp_interfaces[if_name]['params'] = elem['params'] else: tmp_interfaces[if_name]['params'] = None nets = {'4': None, '6': None} if not 'networks' in elem: tmp_interfaces[if_name]['networks'] = nets continue for network in elem['networks']: try: net = luna.Network(name=network) except RuntimeError: err_msg = "No such network '{}'".format(network) return True, False, err_msg if net.version in nets: err_msg = "The can be only one v4 and one v6 network" return True, False, err_msg nets[str(net.version)] = net.name tmp_interfaces[if_name]['networks'] = nets data['interfaces'] = tmp_interfaces changed = False ret = True try: group = luna.Group(name=name) except RuntimeError: args = data.copy() if args['osimage'] is None: err_msg = "OsImage should be specified" return True, False, err_msg args['name'] = name args['create'] = True args['interfaces'] = data['interfaces'].keys() group = luna.Group(**args) changed = True keys = ['prescript', 'postscript', 'partscript', 'torrent_if', 'comment'] group_show = group.show() for key in keys: if data[key] is None: continue if group_show[key] != data[key]: ret &= group.set(key, data[key]) changed = True # FIXME # need to change API in luna if (data['domain'] is not None and group_show['domain'] != '[' + data['domain'] + ']'): ret &= group.set_domain(data['domain']) changed = True if (data['bmcsetup'] is not None and group_show['bmcsetup'] != '[' + data['bmcsetup'] + ']'): ret &= group.bmcsetup(data['bmcsetup']) changed = True if (data['osimage'] is not None and group_show['osimage'] != '[' + data['osimage'] + ']'): ret &= group.osimage(data['osimage']) changed = True # make sure sets of the interfaces are the same ansible_ifs = set(data['interfaces'].keys()) configured_ifs = set(group.list_ifs().keys()) ifs_to_delete = [e for e in configured_ifs if e not in ansible_ifs] ifs_to_add = [e for e in ansible_ifs if e not in configured_ifs] for interface in ifs_to_delete: changed = True ret &= group.del_interface(interface) for interface in ifs_to_add: changed = True ret &= group.add_interface(interface) # now make sure we have same nets assigned for interface in ansible_ifs: if_json = group.show_if(interface) if_params = data['interfaces'][interface]['params'] if (if_params is not None and if_params != group.get_if_params(interface)): ret &= group.set_if_params(interface, if_params) changed = True for net_ver in ['4', '6']: ansible_net = data['interfaces'][interface]['networks'][net_ver] configured_net = if_json['network'][net_ver]['name'] or None if ansible_net == configured_net: continue if ansible_net is None: group.del_net_from_if(interface, configured_net) changed = True else: if configured_net is not None: ret &= group.del_net_from_if(interface, configured_net) ret &= group.set_net_to_if(interface, ansible_net) changed = True return not ret, changed, ""
import luna #group = luna.Group(create = True, name = 'compute1', osimage = 'compute1', bmcsetup = 'base', bmcnetwork = 'internal') #group = luna.Group(create = True, name = 'compute2', osimage = 'compute1', bmcsetup = 'base', bmcnetwork = 'internal', interfaces = ['eth0']) group = luna.Group('compute2') group.add_interface('eht1') group.set_net_to_if('eht1', 'internal') group.del_net_from_if('eht1') group.del_interface('eht1') group.set_if_parms('eth0', 'BOOTPROTO=none\nONBOOT=yes') print group.get_if_parms('eth0')
def _get_nodes(self, group=None, nodelist=None): def transform_node_dict(nodes, node): node_dict = nodes[node] ret_dict = {'node': node, 'BOOTIF': '', 'BMC': ''} if 'interfaces' in node_dict: if 'BOOTIF' in node_dict['interfaces']: ret_dict['BOOTIF'] = node_dict['interfaces']['BOOTIF'][4] if 'BMC' in node_dict['interfaces']: ret_dict['BMC'] = node_dict['interfaces']['BMC'][4] return ret_dict if not luna_present: log.error("Luna 1.2 is not installed") return [] nodes = [] av_groups = luna.list('group') if group is None: groups = av_groups else: if group not in av_groups: self.log.error("No such group '{}'".format(group)) return [] groups = [group] for group_name in groups: group = luna.Group(group_name) domain = group.boot_params['domain'] group_nodes = group.list_nodes() sorted_keys = group_nodes.keys() sorted_keys.sort() ipmi_username = '' ipmi_password = '' if 'bmcsetup' in group.install_params: bmcsetup = group.install_params['bmcsetup'] if 'user' in bmcsetup: ipmi_username = bmcsetup['user'] if 'password' in bmcsetup: ipmi_password = bmcsetup['password'] for node_name in sorted_keys: node_dict = transform_node_dict(group_nodes, node_name) node_dict['ipmi_username'] = ipmi_username node_dict['ipmi_password'] = ipmi_password node_dict['hostname'] = node_name if domain: node_dict['hostname'] += "." + domain nodes.append(node_dict) if not nodelist: return nodes nodelist = ",".join(nodelist) if not hostlist_present: self.log.info( "hostlist is not installed. List of nodes will not be expanded" ) nodelist = nodelist.split(",") else: nodelist = hostlist.expand_hostlist(nodelist) return filter(lambda x: x['node'] in nodelist, nodes)
def test_creation_group(self): bmcsetup = luna.BMCSetup(name='bmcsetup', mongo_db=self.db, create=True) net = luna.Network(name='cluster', NETWORK='10.11.0.0', PREFIX=16, mongo_db=self.db, create=True) nics = ['eth0', 'eth1'] group = luna.Group(name='testgroup2', osimage=self.osimage.name, bmcsetup=bmcsetup.name, mongo_db=self.db, interfaces=nics, domain=net.name, torrent_if=nics[1], create=True) doc = self.db['group'].find_one({'_id': group._id}) expected = { 'torrent_if': nics[1], 'partscript': 'mount -t tmpfs tmpfs /sysroot', 'postscript': ('cat << EOF >> /sysroot/etc/fstab\n' + 'tmpfs / tmpfs defaults 0 0\n' + 'EOF'), 'name': 'testgroup2', 'bmcsetup': bmcsetup.DBRef, 'domain': net.DBRef, '_use_': { 'cluster': { str(self.cluster._id): 1 }, 'osimage': { str(self.osimage._id): 1 }, 'network': { str(net._id): 1, }, 'bmcsetup': { str(bmcsetup._id): 1 }, }, 'osimage': self.osimage.DBRef, 'comment': '', } for attr in expected: self.assertEqual(doc[attr], expected[attr]) # check interfaces if_dict = doc['interfaces'] self.assertEqual(len(if_dict), len(nics)) for uuid in if_dict: self.assertIn(if_dict[uuid]['name'], nics) self.assertEqual(if_dict[uuid]['params'], '') self.assertEqual(if_dict[uuid]['network'], {'4': None, '6': None}) nics.remove(if_dict[uuid]['name'])
def setUp( self, mock_rpm_addmacro, mock_rpm_transactionset, ): print packages = [ { 'VERSION': '3.10', 'RELEASE': '999-el0', 'ARCH': 'x86_64' }, ] mock_rpm_transactionset.return_value.dbMatch.return_value = packages self.sandbox = Sandbox() self.db = self.sandbox.db self.path = self.sandbox.path #osimage_path = self.sandbox.create_osimage() self.cluster = luna.Cluster(mongo_db=self.db, create=True, path=self.path, user=getpass.getuser()) self.cluster.set("frontend_address", "127.0.0.1") self.osimage = luna.OsImage(name='testosimage', path=self.path, mongo_db=self.db, create=True) self.bmcsetup = luna.BMCSetup(name='bmcsetup', mongo_db=self.db, create=True) self.net1 = luna.Network(name='cluster', NETWORK='10.11.0.0', PREFIX=16, mongo_db=self.db, create=True) self.net2 = luna.Network(name='external', NETWORK='10.12.0.0', PREFIX=16, mongo_db=self.db, create=True) self.net3 = luna.Network(name='ib', NETWORK='10.13.0.0', PREFIX=16, mongo_db=self.db, create=True) self.net6 = luna.Network(name='net6', NETWORK='fe80::', PREFIX=64, mongo_db=self.db, create=True, version=6) self.prescript = 'pre' self.postscript = 'post' self.partscript = 'part' self.nics = {'eth0': 'PARM=1', 'eth1': 'PARM=2', 'ib0': 'PARM=3'} self.group = luna.Group(name='compute', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True)
NETMASK='255.255.255.0') ifcfg2 = luna.IfCfg(name='internal2', create=True, NETWORK='192.168.2.0', PREFIX=24, NETMASK='255.255.255.0') ifcfg3 = luna.IfCfg(name='internal3', create=True, NETWORK='192.168.3.0', PREFIX=24, NETMASK='255.255.255.0') ipmi = luna.IfCfg(name='ipmi', create=True, NETWORK='10.10.0.0', PREFIX=16) bmc = luna.BMCSetup(name='base', create=True) osimage = luna.OsImage(create=True, name='compute1', path='/os/compute-image', kernver='3.10.0-327.3.1.el7.x86_64') osimage = luna.OsImage(create=True, name='compute2', path='/os/compute-image-2', kernver='3.10.0-327.3.1.el7.x86_64') group = luna.Group(create=True, name='compute-group', bmcsetup='base', bmcnetwork='ipmi', osimage='compute1', interfaces={ 'eth0': 'internal1', 'eth1': 'internal2' })
def setUp( self, mock_rpm_addmacro, mock_rpm_transactionset, ): print packages = [ { 'VERSION': '3.10', 'RELEASE': '999-el0', 'ARCH': 'x86_64' }, ] mock_rpm_addmacro.return_value = True mock_rpm_transactionset.return_value.dbMatch.return_value = packages self.sandbox = Sandbox() self.db = self.sandbox.db self.path = self.sandbox.path self.cluster = luna.Cluster(mongo_db=self.db, create=True, path=self.path, user=getpass.getuser()) self.cluster.set('path', self.path) self.cluster.set('frontend_address', '127.0.0.1') self.osimage = luna.OsImage(name='testosimage', path=self.path, mongo_db=self.db, create=True) self.net1 = luna.Network( 'testnet1', mongo_db=self.db, create=True, NETWORK='10.50.0.0', PREFIX=16, ) self.net2 = luna.Network( 'testnet2', mongo_db=self.db, create=True, NETWORK='10.51.0.0', PREFIX=16, ) self.group = luna.Group( name='testgroup', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True, ) self.group_new = luna.Group( name='testgroup_new', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True, ) self.node = luna.Node( group=self.group.name, mongo_db=self.db, create=True, ) self.boot_expected_dict = { 'domain': '', 'initrd_file': '', 'mac': '', 'kernel_file': '', 'localboot': 0, 'name': 'node001', 'service': 0, 'net': {}, 'hostname': 'node001', 'kern_opts': '', 'bootproto': 'dhcp' } self.install_expected_dict = { 'torrent_if': '', 'setupbmc': True, 'partscript': 'mount -t tmpfs tmpfs /sysroot', 'name': 'node001', 'tarball': '', 'bmcsetup': {}, 'interfaces': { 'BOOTIF': { 'options': '', '4': { 'ip': '', 'netmask': '', 'prefix': '', }, '6': { 'ip': '', 'netmask': '', 'prefix': '', } }, 'eth0': { 'options': '', '4': { 'ip': '', 'netmask': '', 'prefix': '', }, '6': { 'ip': '', 'netmask': '', 'prefix': '', } } }, 'prescript': '', 'domain': '', 'hostname': 'node001', 'postscript': ('cat << EOF >> /sysroot/etc/fstab\n' + 'tmpfs / tmpfs defaults 0 0\n' + 'EOF'), 'kernopts': '', 'kernver': '3.10-999-el0.x86_64', 'torrent': '', 'mac': '', }
def test_node_change_group(self): # create 3 groups group1 = self.group group2 = luna.Group( name='testgroup2', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True, ) group3 = luna.Group( name='testgroup3', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth1'], create=True, ) group4 = luna.Group( name='testgroup4', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth3'], create=True, ) # create 3 networks net1 = luna.Network( 'testnet1', mongo_db=self.db, create=True, NETWORK='10.50.0.0', PREFIX=16, ) net2 = luna.Network( 'testnet2', mongo_db=self.db, create=True, NETWORK='10.51.0.0', PREFIX=16, ) net3 = luna.Network( 'testnet3', mongo_db=self.db, create=True, NETWORK='10.52.0.0', PREFIX=16, ) # assign 2 networks to interfaces # group1: {'eth0': net1} # group2 {'eth0': net1, 'em1': net2} # group3 {'em1': net1, 'eth1': net2} # group4 {'eth3': net3} group2.add_interface('em1') group3.add_interface('em1') group1.set_net_to_if('eth0', net1.name) group2.set_net_to_if('eth0', net1.name) group3.set_net_to_if('eth1', net2.name) group4.set_net_to_if('eth3', net3.name) group2.set_net_to_if('em1', net2.name) group3.set_net_to_if('em1', net1.name) self.node = luna.Node( name=self.node.name, mongo_db=self.db, ) # create 9 more nodes nodes = [] for i in range(10): nodes.append( luna.Node( group=self.group, create=True, mongo_db=self.db, )) # will do tests with node005 node005 = luna.Node('node005', mongo_db=self.db, group=self.group) # check did we get desired config node_json = self.db['node'].find_one({'name': node005.name}) net1_json = self.db['network'].find_one({'name': net1.name}) self.assertEqual(node_json['group'], group1.DBRef) for k in node_json['interfaces']: self.assertEqual(node_json['interfaces'][k], {'4': 5, '6': None}) self.assertEqual(len(net1_json['freelist']), 1) self.assertEqual(net1_json['freelist'][0]['start'], 12) #node_json['interfaces'], net1_json['freelist'] # # change group first time: # self.assertEqual(node005.set_group(group2.name), True) # updating group objects group1 = luna.Group( name=group1.name, mongo_db=self.db, ) group2 = luna.Group( name=group2.name, mongo_db=self.db, ) node_json = self.db['node'].find_one({'name': node005.name}) group2_json = self.db['group'].find_one({'name': group2.name}) net1_json = self.db['network'].find_one({'name': net1.name}) net2_json = self.db['network'].find_one({'name': net2.name}) # should be 2 interfaces now self.assertEqual(len(node_json['interfaces']), 2) # those interfaces should be the ones from group2 for uid in node_json['interfaces']: self.assertIn(uid, group2_json['interfaces'].keys()) # check if eth0 has the same IP adress: eth0_uuid = '' em1_uuid = '' for if_uid in group2_json['interfaces']: if group2_json['interfaces'][if_uid]['name'] == 'eth0': eth0_uuid = if_uid if group2_json['interfaces'][if_uid]['name'] == 'em1': em1_uuid = if_uid # check if we found self.assertIsNot(eth0_uuid, '') self.assertIsNot(em1_uuid, '') # should be 5 self.assertEqual(node_json['interfaces'][eth0_uuid], { '4': 5, '6': None }) # another should be 1 self.assertEqual(node_json['interfaces'][em1_uuid], { '4': 1, '6': None }) # check network self.assertEqual(net1_json['freelist'], [{'start': 12, 'end': 65533}]) self.assertEqual(net2_json['freelist'], [{'start': 2, 'end': 65533}]) # # change group second time # self.assertEqual(node005.set_group(group3.name), True) # fetch the data from DB node_json = self.db['node'].find_one({'name': node005.name}) group3_json = self.db['group'].find_one({'name': group3.name}) net1_json = self.db['network'].find_one({'name': net1.name}) net2_json = self.db['network'].find_one({'name': net2.name}) # try to find uuids of the interfaces eth1_uuid = '' em1_uuid = '' for if_uid in group3_json['interfaces']: if group3_json['interfaces'][if_uid]['name'] == 'eth1': eth1_uuid = if_uid if group3_json['interfaces'][if_uid]['name'] == 'em1': em1_uuid = if_uid # check if we found self.assertIsNot(eth1_uuid, '') self.assertIsNot(em1_uuid, '') # should be 1 self.assertEqual(node_json['interfaces'][eth1_uuid], { '4': 1, '6': None }) # another should be 5 self.assertEqual(node_json['interfaces'][em1_uuid], { '4': 5, '6': None }) # # change group third time # self.assertEqual(node005.set_group(group4.name), True) node_json = self.db['node'].find_one({'name': node005.name}) net1_json = self.db['network'].find_one({'name': net1.name}) net2_json = self.db['network'].find_one({'name': net2.name}) net3_json = self.db['network'].find_one({'name': net3.name}) self.assertEqual(net1_json['freelist'], [{ 'start': 5, u'end': 5 }, { 'start': 12, 'end': 65533 }]) self.assertEqual(net2_json['freelist'], [{'start': 1, 'end': 65533}]) self.assertEqual(net3_json['freelist'], [{'start': 2, 'end': 65533}])
import luna group = luna.Group('compute1') #print group.install_params node = luna.Node('node001') print node.install_params
import luna import pymongo #client = pymongo.MongoClient() #client.drop_database('luna') #opt = luna.Options(create = True) #ifcfg1 = luna.IfCfg(name = 'internal1', create=True, NETWORK = '192.168.1.0', PREFIX = 24, NETMASK = '255.255.255.0' ) #ifcfg2 = luna.IfCfg(name = 'internal2', create=True, NETWORK = '192.168.2.0', PREFIX = 24, NETMASK = '255.255.255.0' ) #ifcfg3 = luna.IfCfg(name = 'internal3', create=True, NETWORK = '192.168.3.0', PREFIX = 24, NETMASK = '255.255.255.0' ) #ipmi = luna.IfCfg(name = 'ipmi', create=True, NETWORK = '10.10.0.0', PREFIX = 16 ) #bmc = luna.BMCSetup(name = 'base', create = True) #osimage = luna.OsImage(create=True, name='compute1', path='/os/compute-image', kernver='3.10.0-327.3.1.el7.x86_64') #osimage = luna.OsImage(create=True, name='compute2', path='/os/compute-image-2', kernver='3.10.0-327.3.1.el7.x86_64') group = luna.Group(name='compute-group') print group.osimage('compute1') print group.nice_json print group.osimage('compute2') print group.nice_json
def setUp( self, mock_rpm_addmacro, mock_rpm_transactionset, ): print packages = [ { 'VERSION': '3.10', 'RELEASE': '999-el0', 'ARCH': 'x86_64' }, ] mock_rpm_transactionset.return_value.dbMatch.return_value = packages self.sandbox = Sandbox() if self.sandbox.dbtype != 'mongo': raise unittest.SkipTest( 'This test can be run only with MongoDB as a backend.') self.db = self.sandbox.db self.path = self.sandbox.path self.cluster = luna.Cluster(mongo_db=self.db, create=True, path=self.path, user=getpass.getuser()) self.osimage = luna.OsImage(name='testosimage', path=self.path, mongo_db=self.db, create=True) self.group1 = luna.Group(name='testgroup1', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True) self.group2 = luna.Group(name='testgroup2', osimage=self.osimage.name, mongo_db=self.db, interfaces=['BOOTIF'], create=True) self.net11 = luna.Network(name='net11', NETWORK='10.11.0.0', PREFIX=16, mongo_db=self.db, create=True) self.group1.set_net_to_if('eth0', self.net11.name) self.group2.set_net_to_if('BOOTIF', self.net11.name) self.node1 = luna.Node(group=self.group1.name, mongo_db=self.db, create=True) self.node2 = luna.Node(group=self.group2.name, mongo_db=self.db, create=True) self.node1.set_mac('00:11:22:33:44:55') self.node2.set_mac('01:11:22:33:44:55') self.group1 = luna.Group(name=self.group1.name, mongo_db=self.db) self.group2 = luna.Group(name=self.group2.name, mongo_db=self.db) self.net11 = luna.Network(name=self.net11.name, mongo_db=self.db) self.node1 = luna.Node(name=self.node1.name, mongo_db=self.db) self.node2 = luna.Node(name=self.node2.name, mongo_db=self.db)
def setUp( self, mock_rpm_addmacro, mock_rpm_transactionset, ): print packages = [ { 'VERSION': '3.10', 'RELEASE': '999-el0', 'ARCH': 'x86_64' }, ] mock_rpm_transactionset.return_value.dbMatch.return_value = packages self.sandbox = Sandbox() self.db = self.sandbox.db self.path = self.sandbox.path self.cluster = luna.Cluster(mongo_db=self.db, create=True, path=self.path, user=getpass.getuser()) self.osimage = luna.OsImage(name='testosimage', path=self.path, mongo_db=self.db, create=True) self.group = luna.Group(name='testgroup', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True) self.net11 = luna.Network(name='net11', NETWORK='10.11.0.0', PREFIX=16, mongo_db=self.db, create=True) self.net11.set('ns_hostname', 'master') self.net61 = luna.Network(name='net61', NETWORK='fe90::', PREFIX=64, mongo_db=self.db, create=True) self.net61.set('ns_hostname', 'master') self.group.set_net_to_if('eth0', self.net11.name) self.group.set_net_to_if('eth0', self.net61.name) self.group = luna.Group(name=self.group.name, mongo_db=self.db) self.node = luna.Node(group=self.group.name, mongo_db=self.db, create=True) self.switch = luna.Switch(name='sw01', network=self.net11.name, mongo_db=self.db, create=True) self.switch.set('ip', '10.11.1.1') self.otherdev = luna.OtherDev(name='pdu01', network=self.net11.name, ip="10.11.2.1", mongo_db=self.db, create=True) self.net11 = luna.Network(name=self.net11.name, mongo_db=self.db) self.node = luna.Node(name=self.node.name, mongo_db=self.db) self.group = luna.Group(name=self.group.name, mongo_db=self.db)
def setUp( self, mock_rpm_addmacro, mock_rpm_transactionset, ): print packages = [ { 'VERSION': '3.10', 'RELEASE': '999-el0', 'ARCH': 'x86_64' }, ] mock_rpm_transactionset.return_value.dbMatch.return_value = packages self.sandbox = Sandbox() self.db = self.sandbox.db self.path = self.sandbox.path self.cluster = luna.Cluster(mongo_db=self.db, create=True, path=self.path, user=getpass.getuser()) self.cluster.set("frontend_address", "127.0.0.1") self.osimage = luna.OsImage(name='testosimage', path=self.path, mongo_db=self.db, create=True) self.bmcsetup = luna.BMCSetup(name='bmcsetup', mongo_db=self.db, create=True) self.net1 = luna.Network(name='cluster', NETWORK='10.11.0.0', PREFIX=16, mongo_db=self.db, create=True) self.net2 = luna.Network(name='external', NETWORK='10.12.0.0', PREFIX=16, mongo_db=self.db, create=True) self.net3 = luna.Network(name='ib', NETWORK='10.13.0.0', PREFIX=16, mongo_db=self.db, create=True) self.prescript = 'pre' self.postscript = 'post' self.partscript = 'part' self.nics = {'BOOTIF': 'PARM=1', 'eth1': 'PARM=2', 'ib0': 'PARM=3'} self.group = luna.Group(name='compute', osimage=self.osimage.name, mongo_db=self.db, interfaces=['BOOTIF'], create=True) # mocking osimage boot stuff with mock.patch('os.path'), \ mock.patch('shutil.copy'), \ mock.patch('os.remove'), \ mock.patch('os.chown'), \ mock.patch('os.chmod'), \ mock.patch('subprocess.Popen') as mock_subprocess_popen, \ mock.patch('os.open'), \ mock.patch('os.chroot'), \ mock.patch('os.fchdir'), \ mock.patch('os.close'), \ mock.patch('os.chdir'), \ mock.patch('shutil.move'), \ mock.patch('libtorrent.add_files'), \ mock.patch('libtorrent.set_piece_hashes'): (mock_subprocess_popen.return_value.stderr.readline.return_value ) = '' self.osimage.copy_boot() self.osimage.create_tarball() self.osimage.create_torrent() group_json = self.db['group'].find_one({'_id': self.group._id}) osimage_json = self.db['osimage'].find_one({'_id': self.osimage._id}) self.install_expected_dict = { 'torrent_if': '', 'partscript': group_json['partscript'], 'tarball': osimage_json['tarball'] + '.tgz', 'bmcsetup': {}, 'interfaces': { 'BOOTIF': { 'options': '', '4': { 'ip': '', 'netmask': '', 'prefix': '', }, '6': { 'ip': '', 'netmask': '', 'prefix': '', } } }, 'prescript': '', 'domain': '', 'postscript': group_json['postscript'], 'kernopts': '', 'kernver': '3.10-999-el0.x86_64', 'torrent': osimage_json['torrent'] + '.torrent' }
import luna node1 = luna.Node(group='compute-group', create=True) print str(node1.show()) node = luna.Node('node015') print str(node.show()) group = luna.Group('compute-group') print str(group.show())
def setUp( self, mock_rpm_addmacro, mock_rpm_transactionset, ): print packages = [ { 'VERSION': '3.10', 'RELEASE': '999-el0', 'ARCH': 'x86_64' }, ] mock_rpm_transactionset.return_value.dbMatch.return_value = packages self.sandbox = Sandbox() self.db = self.sandbox.db self.path = self.sandbox.path self.cluster = luna.Cluster(mongo_db=self.db, create=True, path=self.path, user=getpass.getuser()) self.cluster.set('path', self.path) self.cluster.set('frontend_address', '127.0.0.1') self.osimage = luna.OsImage(name='testosimage', path=self.path, mongo_db=self.db, create=True) self.net = luna.Network( 'testnet', mongo_db=self.db, create=True, NETWORK='fe80::', PREFIX=64, ) self.net.set('ns_hostname', 'master') self.group = luna.Group( name='testgroup', osimage=self.osimage.name, mongo_db=self.db, interfaces=['eth0'], create=True, ) self.group.set_net_to_if('eth0', self.net.name) self.nodes = [] for i in range(10): self.nodes.append( luna.Node( group=self.group, create=True, mongo_db=self.db, )) self.net = luna.Network(name=self.net.name, mongo_db=self.db)