def create_instances(self, req, resp):
host = req.get_param(name='h')
if host is None:
return '-h(host) need'
name = req.get_param(name='n')
flavor = req.get_param(name='flavor')
instance_count = req.get_param(name='instance_count')
network_pool = req.get_param(name='network_pool')
room = req.get_param(name='r')
strategy = req.get_param(name='s') or 'max_use'
root_image = req.get_param(
name='root_image') or kvm_config.get('root_images_template')
if name is None:
return '-n(name) need'
if flavor is None:
return '--flavor(flavor) need'
if instance_count is None or int(instance_count) < 1:
return '--instance_count(instance_count) need'
storage_pool = req.get_param(
name='storage_pool') or kvm_config.get('volume_group')
bridge = req.get_param(name='bridge') or kvm_config.get('bridge')
netdev = req.get_param(name='netdev') or kvm_config.get('netdev')
vlan_id = req.get_param(name='vlan_id')
hosts = self._get_client(
req, instance_count=instance_count, room=room, strategy=strategy)
ips = self._get_ip(
network_pool=network_pool, count=instance_count, room=room)
if len(ips) < instance_count:
return 'not have enough IP ,only have %d IP' % len(ips)
if len(hosts) < instance_count:
return 'not have enough host ,only have %d host' % len(hosts)
result = []
try:
for key, item in enumerate(hosts):
res = self.__create_instance_common(
host=item,
name=name + '_' + key,
flavor=flavor,
ipv4_addr=ips[key].ipv4_addr,
root_image=root_image,
storage_pool=storage_pool,
bridge=bridge,
netdev=netdev,
vlan_id=vlan_id)
result.append(res)
return result
except Exception as e:
log_error(e)
raise Exception(e)
def create_storage_pool(self, req, resp):
host = req.get_param(name='h')
if host is None:
return '-h(host) need'
host = self._get_client(req)
name = req.get_param(
name='storage_pool') or kvm_config.get('volume_group')
storage_type = req.get_param(name='storage_type') or 'default'
stg_type = req.get_param(name='stg_type') or 'logical'
source = req.get_param(name='source')
target = req.get_param(name='target')
ceph_pool = req.get_param(name='ceph_pool')
ceph_host = req.get_param(name='ceph_host')
ceph_user = req.get_param(name='ceph_user')
secret = req.get_param(name='secret')
netfs_host = req.get_param(name='netfs_host')
source_format = req.get_param(name='source_format')
if name is None:
return '--name(name) need'
if stg_type is None:
return '--stg_type(stg_type) need'
if target is None:
target = name
instance = wvmStorages(host=host, conn=self.conn)
if storage_type == 'ceph':
return instance.create_storage_ceph(stg_type, name, ceph_pool,
ceph_host, ceph_user, secret)
elif storage_type == 'netfs':
return instance.create_storage_netfs(stg_type, name, netfs_host,
source, source_format, target)
else:
return instance.create_storage(stg_type, name, source, target)
def create_instance(self, req, resp):
name = req.get_param(name='n')
flavor = req.get_param(name='flavor')
network_pool = req.get_param(name='network_pool')
ipv4_addr = req.get_param(name='ipv4_addr')
ipv4_gw = req.get_param(name='ipv4_gw')
room = req.get_param(name='r')
root_image = req.get_param(
name='root_image') or kvm_config.get('root_images_template')
if network_pool is not None:
ips = self._get_ip(network_pool=network_pool, room=room)
ipv4_addr = ips[0]['ipv4_addr']
ipv4_gw = ips[0]['ipv4_gw']
if name is None:
return '-n(name) need'
if flavor is None:
return '--flavor(flavor) need'
if ipv4_addr is None:
return '--ipv4_addr(ipv4_addr) need'
host = self._get_client(req, room=room)
storage_pool = req.get_param(
name='storage_pool') or kvm_config.get('volume_group')
bridge = req.get_param(name='bridge') or kvm_config.get('bridge')
netdev = req.get_param(name='netdev') or kvm_config.get('netdev')
vlan_id = req.get_param(name='vlan_id')
result = []
try:
res = self.__create_instance_common(
host=host,
name=name,
flavor=flavor,
ipv4_addr=ipv4_addr,
root_image=root_image,
storage_pool=storage_pool,
bridge=bridge,
netdev=netdev,
vlan_id=vlan_id)
result.append(res)
return result
except Exception as e:
log_error(e)
raise Exception(e)
def list_volume(self, req, resp):
host = req.get_param(name='h')
if host is None:
return '-h(host) need'
host = self._get_client(req)
storage_pool = req.get_param(
name='storage_pool') or kvm_config.get('volume_group')
if storage_pool is None:
return '--storage_pool(storage_pool) need'
instance = wvmStorage(host=host, conn=self.conn, pool=storage_pool)
return instance.get_volumes()
def creaete_volume(self, req, resp):
host = req.get_param(name='h')
if host is None:
return '-h(host) need'
host = self._get_client(req)
storage_pool = req.get_param(
name='storage_pool') or kvm_config.get('volume_group')
volume_name = req.get_param(
name='volume_name') or req.get_param('name')
if storage_pool is None:
return '--storage_pool(storage_pool) need'
if volume_name is None:
return '--volume_name(volume_name) need'
disksize = req.get_param(name='disksize') or kvm_config.get('disksize')
format = req.get_param(name='format') or 'xfs'
return self._create_volume(
host=host,
volume_name=volume_name,
disksize=disksize,
storage_pool=storage_pool,
format=format)
def create_iface(self, req, resp):
host = req.get_param(name='h')
if host is None:
return '-h(host) need'
host = self._get_client(req)
itype = req.get_param(name='itype') or 'bridge'
iface_name = req.get_param(name='iface_name')
netdev = req.get_param(name='netdev') or kvm_config.get('netdev')
ipv4_type = req.get_param(name='ipv4_type') or 'static'
ipv4_addr = req.get_param(name='ipv4_addr')
vlan_id = req.get_param(name='vlan_id')
bond_mode = req.get_param(
name='bond_mode') or kvm_config.get('bond_mode')
return self._create_network(
host=host,
itype=itype,
iface_name=iface_name,
netdev=netdev,
ipv4_type=ipv4_type,
ipv4_addr=ipv4_addr,
vlan_id=vlan_id,
bond_mode=bond_mode)
def migrate(self, req, resp):
host = req.get_param(name='h')
if host is None:
return '-h(host) need'
name = req.get_param(name='n')
host = self._get_client(req)
to_host = req._params['t']
if name is None:
return '-n(name) need'
if to_host is None:
return '-t(to_host) need'
undefine = kvm_config.get('migrate_undefine')
unsafe = kvm_config.get('migrate_unsafe')
live = kvm_config.get('migrate_live')
instance = wvmInstance(host=host, conn=self.conn, vname=name)
to_instance = wvmInstances(host=to_host, conn=self.conn)
return to_instance.moveto(
conn=instance,
name=name,
live=live,
unsafe=unsafe,
undefine=undefine)
def info_volume(self, req, resp):
host = req.get_param(name='h')
if host is None:
return '-h(host) need'
host = self._get_client(req)
storage_pool = req.get_param(
name='storage_pool') or kvm_config.get('volume_group')
volume_name = req.get_param(
name='volume_name') or req.get_param('name')
if storage_pool is None:
return '--storage_pool(storage_pool) need'
if volume_name is None:
return '--volume_name(volume_name) need'
instance = wvmStorage(host=host, conn=self.conn, pool=storage_pool)
volume = instance.get_volume(name=volume_name)
return volume.info()
def clone_volume(self, req, resp):
host = req.get_param(name='h')
if host is None:
return '-h(host) need'
host = self._get_client(req)
storage_pool = req.get_param(
name='storage_pool') or kvm_config.get('volume_group')
if storage_pool is None:
return '--storage_pool(storage_pool) need'
name = req.get_param(name='from')
if name is None:
return '--from(from) need'
clone = req.get_param(name='to')
if clone is None:
return '--to(to) need'
instance = wvmStorage(host=host, conn=self.conn, pool=storage_pool)
return instance.clone_volume(name, clone, vol_fmt=None, metadata=False)
def _create_volume(self,
host,
volume_name,
disksize,
storage_pool=kvm_config.get('volume_group'),
format='qcow2',
metadata=False):
if storage_pool is None:
return '--storage_pool(storage pool) need'
if volume_name is None:
return '--volume_name(volume_name) need'
if disksize is None:
return '--disksize(disksize G) need'
try:
instance = wvmCreate(host=host, conn=self.conn)
#check exist
exist = instance.get_volume_path(volume=volume_name)
if exist:
return volume_name
instance.create_volume(
storage=storage_pool,
name=volume_name,
size=disksize,
format=format,
metadata=metadata)
if format in ['xfs', 'ext4']:
ssh_result = ssh_remote_execute(
host=host,
cmd="sudo mkfs.%s %s" %
(format, '/dev/' + storage_pool + '/' + volume_name))
if ssh_result is None:
raise Exception('copy base dir %s error' % '/dev/' +
storage_pool + '/' + volume_name)
return volume_name
except Exception as e:
log_error(e)
raise Exception(e)
def __create_instance_common(self,
host,
name,
flavor,
ipv4_addr,
root_image,
storage_pool,
bridge,
netdev,
vlan_id,
format='xfs',
metadata=False):
uuid = util.randomUUID()
mac = util.randomMAC()
if flavor is None:
return '--flavor(flavor) need'
if host is None:
return '-h(host) need'
if name is None:
return '-n(name) need'
if ipv4_addr is None:
return '--ipv4_addr(ipv4_addr) need'
instance = wvmCreate(host=host, conn=self.conn)
vcpu, memory, disksize = self.__get_cpu_memory_disksize(flavor=flavor)
if vcpu is None:
return '-c(vcpu) need'
if memory is None:
return '-d(memory) need'
try:
###network
self._create_network(
host=host,
itype='bridge',
iface_name=bridge,
netdev=netdev,
ipv4_type='static',
ipv4_addr=ipv4_addr,
vlan_id=vlan_id)
###volume
self._create_volume(
host=host,
volume_name=name,
disksize=disksize,
storage_pool=storage_pool,
format=format)
#copy base_image
base_dir = kvm_config.get('kvm_data_rootdir') + '/' + name
base_image = base_dir + '/' + uuid + '.qcow2'
ssh_result = ssh_remote_execute(
host=host,
cmd="sudo mkdir -p %s && sudo cp %s %s && sudo chown -R qemu:qemu %s"
% (base_dir, root_image, base_image, base_dir))
if ssh_result is None:
raise Exception('copy base dir %s error' % base_dir)
root_image = base_image
###create
instance.create_instance(
name=name,
vcpu=vcpu,
memory=memory,
root_image=root_image,
uuid=uuid,
mac=mac,
bridge=bridge)
vminstance = wvmInstance(host=host, conn=self.conn, vname=name)
vminstance.start()
vminstance.set_autostart(flag=2)
return {
'name': name,
'uuid': uuid,
'vcpu': vcpu,
'memory': memory,
'disksize': disksize,
'mac': mac,
'metal': host
}
except Exception as e:
log_error(e)
raise Exception(e)
def __init__(self):
self.login = kvm_config.get('user')
self.passwd = kvm_config.get('password')
self.conn = 1
self.strategy = ['max_use', 'diffrent_rack', 'diffrent_server']