--- /dev/null
+##############################################################################
+# Copyright (c) 2017 ZTE Corporation and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+import os
+import paramiko
+import scp
+import time
+
+from utils import (
+ WORKSPACE,
+ LD,
+ LI,
+ LW,
+ err_exit,
+ log_bar,
+ path_join,
+ update_config
+)
+
+TIMEOUT = 300
+BLOCK_SIZE = 1024
+
+
+def log_from_stream(res, data, log_func):
+ lines = data.splitlines()
+ res_data = res
+ if res_data:
+ lines[0] = res_data + lines[0]
+ res_data = None
+
+ if not data.endswith("\n"):
+ res_data = lines[-1]
+ del (lines[-1])
+ for string in lines:
+ log_func(string)
+
+ if res_data and len(res_data) >= BLOCK_SIZE:
+ log_func(res_data)
+ res_data = None
+
+ return res_data
+
+
+LEN_OF_NAME_PART = 50
+LEN_OF_SIZE_PART = 15
+
+
+def log_scp(filename, size, send):
+ if size != send:
+ return
+ unit = " B"
+ if size > 1024:
+ size /= 1024
+ unit = " KB"
+ if size > 1024:
+ size /= 1024
+ unit = " MB"
+
+ name_part = 'SCP: ' + filename + ' '
+ size_part = ' ' + str(size) + unit + ' 100%'
+ if len(name_part) <= LEN_OF_NAME_PART:
+ LD(name_part.ljust(LEN_OF_NAME_PART, '.') + size_part.rjust(LEN_OF_SIZE_PART, '.'))
+ else:
+ LD(name_part)
+ LD(" ".ljust(LEN_OF_NAME_PART, '.') + size_part.rjust(LEN_OF_SIZE_PART, '.'))
+
+
+class DaisyServer(object):
+ def __init__(self, name, address, password, remote_dir, bin_file, adapter):
+ self.name = name
+ self.address = address
+ self.password = password
+ self.remote_dir = remote_dir
+ self.bin_file = bin_file
+ self.adapter = adapter
+ self.ssh_client = None
+
+ def connect(self):
+ LI('Try to connect to Daisy Server ...')
+ self.ssh_client = paramiko.SSHClient()
+ self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+ count = 0
+ MAX_COUNT = 120
+ while count < MAX_COUNT:
+ try:
+ self.ssh_client.connect(hostname=self.address,
+ username='root',
+ password=self.password,
+ timeout=TIMEOUT)
+ except (paramiko.ssh_exception.SSHException,
+ paramiko.ssh_exception.NoValidConnectionsError):
+ count += 1
+ LD('Attempted SSH connection %d time(s)' % count)
+ time.sleep(2)
+ else:
+ break
+ if count >= MAX_COUNT:
+ err_exit('SSH connect to Daisy Server failed')
+
+ LI('SSH connection established')
+ LI('Try ssh_run: ls -al')
+ self.ssh_run('ls -al', check=True)
+
+ def close(self):
+ self.ssh_client.close()
+
+ def ssh_exec_cmd(self, cmd):
+ stdin, stdout, stderr = self.ssh_client.exec_command(cmd, timeout=TIMEOUT)
+ response = stdout.read().strip()
+ error = stderr.read().strip()
+
+ if error:
+ self.close()
+ err_exit('SSH client error occurred')
+ else:
+ return response
+
+ def ssh_run(self, cmd, check=False, exit_msg='Ssh_run failed'):
+ transport = self.ssh_client.get_transport()
+ transport.set_keepalive(1)
+ session = transport.open_session()
+ res_data = None
+ session.exec_command(cmd)
+ while True:
+ if session.recv_ready():
+ data = session.recv(BLOCK_SIZE)
+ while data:
+ res_data = log_from_stream(res_data, data, LI)
+ data = session.recv(BLOCK_SIZE)
+ if res_data:
+ LI(res_data)
+ res_data = None
+
+ if session.recv_stderr_ready():
+ data = session.recv_stderr(BLOCK_SIZE)
+ while data:
+ res_data = log_from_stream(res_data, data, LW)
+ data = session.recv_stderr(BLOCK_SIZE)
+ if res_data:
+ LW(res_data)
+ res_data = None
+ if session.exit_status_ready():
+ break
+
+ status = session.recv_exit_status()
+ if check and status:
+ err_exit(exit_msg)
+
+ return status
+
+ def scp_get(self, remote, local='.'):
+ scp_client = scp.SCPClient(self.ssh_client.get_transport(),
+ progress=log_scp,
+ socket_timeout=TIMEOUT)
+ scp_client.get(remote, local_path=local, recursive=True)
+
+ def scp_put(self, local, remote='.'):
+ scp_client = scp.SCPClient(self.ssh_client.get_transport(),
+ progress=log_scp,
+ socket_timeout=TIMEOUT)
+ scp_client.put(local, remote_path=remote, recursive=True)
+
+ def create_dir(self, remote_dir):
+ cmd = 'mkdir -p %s' % remote_dir
+ self.ssh_exec_cmd(cmd)
+
+ def delete_dir(self, remote_dir):
+ cmd = 'if [[ -f {DIR} || -d {DIR} ]]; then rm -fr {DIR}; fi'.format(DIR=remote_dir)
+ self.ssh_exec_cmd(cmd)
+
+ def prepare_files(self):
+ self.delete_dir(self.remote_dir)
+ LI('Copy WORKSPACE directory to Daisy Server')
+ self.scp_put(WORKSPACE, self.remote_dir)
+ time.sleep(2)
+ LI('Copy finished')
+
+ self.create_dir('/home/daisy_install')
+ LI('Write Daisy Server address into daisy.conf')
+ update_config(path_join(WORKSPACE, 'deploy/daisy.conf'),
+ 'daisy_management_ip',
+ self.address,
+ section='DEFAULT')
+ LI('Copy daisy.conf to Daisy Server')
+ self.scp_put(path_join(WORKSPACE, 'deploy/daisy.conf'), '/home/daisy_install/')
+
+ if os.path.dirname(os.path.abspath(self.bin_file)) != WORKSPACE:
+ LI('Copy opnfv.bin to Daisy Server')
+ self.scp_put(self.bin_file, path_join(self.remote_dir, 'opnfv.bin'))
+
+ def install_daisy(self):
+ self.prepare_files()
+ LI('Begin to install Daisy')
+ status = self.ssh_run('%s install' % path_join(self.remote_dir, 'opnfv.bin'))
+ log_bar('Daisy installation completed ! status = %s' % status)
+
+ def prepare_configurations(self):
+ if self.adapter != 'libvirt':
+ return
+ LI('Prepare some configuration files')
+ cmd = 'bash {script} -n {net_file}'.format(
+ script=path_join(self.remote_dir, 'deploy/prepare.sh'),
+ net_file=path_join(self.remote_dir, 'network.yml'))
+ self.ssh_run(cmd)
+
+ def prepare_cluster(self, deploy_file, net_file):
+ LI('Copy cluster configuration files to Daisy Server')
+ self.scp_put(deploy_file, path_join(self.remote_dir, 'deploy.yml'))
+ self.scp_put(net_file, path_join(self.remote_dir, 'network.yml'))
+
+ self.prepare_configurations()
+
+ LI('Prepare cluster and PXE')
+ cmd = "python {script} --dha {deploy_file} --network {net_file} --cluster \'yes\'".format(
+ script=path_join(self.remote_dir, 'deploy/tempest.py'),
+ deploy_file=path_join(self.remote_dir, 'deploy.yml'),
+ net_file=path_join(self.remote_dir, 'network.yml'))
+ self.ssh_run(cmd, check=True)
+
+ def prepare_host_and_pxe(self):
+ LI('Prepare host and PXE')
+ cmd = "python {script} --dha {deploy_file} --network {net_file} --host \'yes\' --isbare {is_bare}".format(
+ script=path_join(self.remote_dir, 'deploy/tempest.py'),
+ deploy_file=path_join(self.remote_dir, 'deploy.yml'),
+ net_file=path_join(self.remote_dir, 'network.yml'),
+ is_bare=1 if self.adapter == 'ipmi' else 0)
+ self.ssh_run(cmd, check=True)
+
+ def install_virtual_nodes(self):
+ LI('Daisy install virtual nodes')
+ cmd = "python {script} --dha {deploy_file} --network {net_file} --install \'yes\'".format(
+ script=path_join(self.remote_dir, 'deploy/tempest.py'),
+ deploy_file=path_join(self.remote_dir, 'deploy.yml'),
+ net_file=path_join(self.remote_dir, 'network.yml'))
+ self.ssh_run(cmd, check=True)
+
+ def check_os_installation(self, nodes_num):
+ LI('Check Operating System installation progress')
+ cmd = '{script} -d {is_bare} -n {nodes_num}'.format(
+ script=path_join(self.remote_dir, 'deploy/check_os_progress.sh'),
+ is_bare=1 if self.adapter == 'ipmi' else 0,
+ nodes_num=nodes_num)
+ self.ssh_run(cmd, check=True)
+
+ def check_openstack_installation(self, nodes_num):
+ LI('Check OpenStack installation progress')
+ cmd = '{script} -n {nodes_num}'.format(
+ script=path_join(self.remote_dir, 'deploy/check_openstack_progress.sh'),
+ nodes_num=nodes_num)
+ self.ssh_run(cmd, check=True)
+
+ def post_deploy(self):
+ LI('Post deploy ...')
+ cmd = 'bash {script} -n {net_file}'.format(
+ script=path_join(self.remote_dir, 'deploy/post.sh'),
+ net_file=path_join(self.remote_dir, 'network.yml'))
+ self.ssh_run(cmd, check=False)
--- /dev/null
+##############################################################################
+# Copyright (c) 2017 ZTE Corporation and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+##############################################################################
+# TODO:
+# [ ] 1. specify VM templates (Server, Controller & Compute) in deploy.yml
+# [ ] 2. specify network templates in deploy.yml
+# [ ] 3. specify adapter(ipmi, libvirt) in deploy.yml
+# [ ] 4. get ipmi user/password from PDF (Pod Descriptor File)
+# [ ] 5. get pxe bridge from jjb
+# [ ] 6. enlarge the vm size of Controller & Compute in deploy.yml
+##############################################################################
+
+import argparse
+import yaml
+
+from utils import (
+ WORKSPACE,
+ save_log_to_file,
+ LI,
+ log_bar,
+ path_join,
+ check_sudo_privilege,
+ check_file_exists,
+ make_file_executable,
+ confirm_dir_exists
+)
+
+from environment import (
+ DaisyEnvironment,
+)
+
+
+class DaisyDeployment(object):
+ def __init__(self, lab_name, pod_name, deploy_file, net_file, bin_file,
+ daisy_only, cleanup_only, remote_dir, work_dir, storage_dir,
+ pxe_bridge, deploy_log):
+ self.lab_name = lab_name
+ self.pod_name = pod_name
+
+ self.deploy_file = deploy_file
+ with open(deploy_file) as yaml_file:
+ self.deploy_struct = yaml.safe_load(yaml_file)
+
+ if not cleanup_only:
+ self.net_file = net_file
+ with open(net_file) as yaml_file:
+ self.net_struct = yaml.safe_load(yaml_file)
+ else:
+ self.net_struct = None
+
+ self.bin_file = bin_file
+ self.daisy_only = daisy_only
+ self.cleanup_only = cleanup_only
+ self.remote_dir = remote_dir
+ self.work_dir = work_dir
+ self.storage_dir = storage_dir
+ self.pxe_bridge = pxe_bridge
+ self.deploy_log = deploy_log
+
+ self.adapter = self._get_adapter_info()
+ LI('The adapter is %s' % self.adapter)
+
+ # TODO: modify the jjb code to provide bridge name
+ if self.adapter == 'libvirt':
+ self.pxe_bridge = 'daisy1'
+ else:
+ self.pxe_bridge = 'br7'
+
+ self.daisy_server_info = self._get_daisy_server_info()
+
+ self.daisy_env = DaisyEnvironment(self.deploy_struct,
+ self.net_struct,
+ self.adapter,
+ self.pxe_bridge,
+ self.daisy_server_info,
+ self.work_dir,
+ self.storage_dir)
+
+ def _get_adapter_info(self):
+ # TODO: specify the adapter info in deploy.yml
+ if 'adapter' in self.deploy_struct:
+ return self.deploy_struct['adapter']
+ elif self.pod_name and 'virtual' in self.pod_name:
+ return 'libvirt'
+ else:
+ return 'ipmi'
+
+ def _get_daisy_server_info(self):
+ address = self.deploy_struct.get('daisy_ip', '10.20.11.2')
+ gateway = self.deploy_struct.get('daisy_gateway', '10.20.11.1')
+ password = self.deploy_struct.get('daisy_passwd', 'r00tme')
+ disk_size = self.deploy_struct.get('disks', {'daisy': 50})['daisy']
+ # TODO: get VM name of daisy server from deploy.yml or vm template
+ name = 'daisy'
+ image = path_join(self.storage_dir, name + '.qcow2')
+
+ return {'name': name,
+ 'image': image,
+ 'address': address,
+ 'gateway': gateway,
+ 'password': password,
+ 'disk_size': disk_size}
+
+ def run(self):
+ self.daisy_env.delete_old_environment()
+ if self.cleanup_only:
+ return
+ self.daisy_env.create_daisy_server()
+ if self.daisy_only:
+ log_bar('Create Daisy Server successfully !')
+ return
+ self.daisy_env.install_daisy(self.remote_dir, self.bin_file)
+ self.daisy_env.deploy(self.deploy_file, self.net_file)
+ log_bar('Daisy deploy successfully !')
+
+
+def config_arg_parser():
+ parser = argparse.ArgumentParser()
+
+ parser.add_argument('-lab', dest='lab_name', action='store', nargs='?',
+ default=None,
+ help='Lab Name')
+ parser.add_argument('-pod', dest='pod_name', action='store', nargs='?',
+ default=None,
+ help='Pod Name')
+
+ parser.add_argument('-bin', dest='bin_file', action='store', nargs='?',
+ default=path_join(WORKSPACE, 'opnfv.bin'),
+ help='OPNFV Daisy BIN File')
+
+ parser.add_argument('-do', dest='daisy_only', action='store_true',
+ default=False,
+ help='Install Daisy Server only')
+ parser.add_argument('-co', dest='cleanup_only', action='store_true',
+ default=False,
+ help='Cleanup VMs and Virtual Networks')
+ # parser.add_argument('-nd', dest='no_daisy', action='store_true',
+ # default=False,
+ # help='Do not install Daisy Server when it exists')
+
+ parser.add_argument('-rdir', dest='remote_dir', action='store', nargs='?',
+ default='/home/daisy',
+ help='Code directory on Daisy Server')
+
+ parser.add_argument('-wdir', dest='work_dir', action='store', nargs='?',
+ default='/tmp/workdir',
+ help='Temporary working directory')
+ parser.add_argument('-sdir', dest='storage_dir', action='store', nargs='?',
+ default='/home/qemu/vms',
+ help='Storage directory for VM images')
+ parser.add_argument('-B', dest='pxe_bridge', action='store', nargs='?',
+ default='pxebr',
+ help='Linux Bridge for booting up the Daisy Server VM '
+ '[default: pxebr]')
+ parser.add_argument('-log', dest='deploy_log', action='store', nargs='?',
+ default=path_join(WORKSPACE, 'deploy.log'),
+ help='Path and name of the deployment log file')
+ return parser
+
+
+def parse_arguments():
+ parser = config_arg_parser()
+ args = parser.parse_args()
+
+ save_log_to_file(args.deploy_log)
+ LI(args)
+
+ conf_base_dir = path_join(WORKSPACE, 'labs', args.lab_name, args.pod_name)
+ deploy_file = path_join(conf_base_dir, 'daisy/config/deploy.yml')
+ net_file = path_join(conf_base_dir, 'daisy/config/network.yml')
+
+ check_file_exists(deploy_file)
+ if not args.cleanup_only:
+ check_file_exists(net_file)
+ make_file_executable(args.bin_file)
+
+ confirm_dir_exists(args.work_dir)
+ confirm_dir_exists(args.storage_dir)
+
+ kwargs = {
+ 'lab_name': args.lab_name,
+ 'pod_name': args.pod_name,
+ 'deploy_file': deploy_file,
+ 'net_file': net_file,
+ 'bin_file': args.bin_file,
+ 'daisy_only': args.daisy_only,
+ 'cleanup_only': args.cleanup_only,
+ 'remote_dir': args.remote_dir,
+ 'work_dir': args.work_dir,
+ 'storage_dir': args.storage_dir,
+ 'pxe_bridge': args.pxe_bridge,
+ 'deploy_log': args.deploy_log
+ }
+ return kwargs
+
+
+def main():
+ check_sudo_privilege()
+ kwargs = parse_arguments()
+ deploy = DaisyDeployment(**kwargs)
+ deploy.run()
+
+
+if __name__ == '__main__':
+ main()
--- /dev/null
+##############################################################################
+# Copyright (c) 2017 ZTE Corporation and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+import os
+import shutil
+import time
+
+from daisy_server import (
+ DaisyServer
+)
+from libvirt_utils import (
+ create_virtual_disk,
+ create_vm,
+ reboot_vm,
+ delete_vm_and_disk,
+ create_virtual_network,
+ delete_virtual_network
+)
+from utils import (
+ WORKSPACE,
+ LI,
+ LW,
+ err_exit,
+ run_shell,
+ path_join,
+ ipmi_reboot_node,
+)
+
+CREATE_QCOW2_PATH = path_join(WORKSPACE, 'tools')
+
+VMDEPLOY_DAISY_SERVER_NET = path_join(WORKSPACE, 'templates/virtual_environment/networks/daisy.xml')
+VMDEPLOY_TARGET_NODE_NET = path_join(WORKSPACE, 'templates/virtual_environment/networks/os-all_in_one.xml')
+VMDEPLOY_DAISY_SERVER_VM = path_join(WORKSPACE, 'templates/virtual_environment/vms/daisy.xml')
+
+BMDEPLOY_DAISY_SERVER_VM = path_join(WORKSPACE, 'templates/physical_environment/vms/daisy.xml')
+
+ALL_IN_ONE_TEMPLATE = path_join(WORKSPACE, 'templates/virtual_environment/vms/all_in_one.xml')
+CONTROLLER_TEMPLATE = path_join(WORKSPACE, 'templates/virtual_environment/vms/controller01.xml')
+COMPUTE_TEMPLATE = path_join(WORKSPACE, 'templates/virtual_environment/vms/computer01.xml')
+VIRT_NET_TEMPLATE_PATH = path_join(WORKSPACE, 'templates/virtual_environment/networks')
+
+
+class DaisyEnvironment(object):
+ def __new__(cls, deploy_struct, net_struct, adapter, pxe_bridge,
+ daisy_server_info, work_dir, storage_dir):
+ if adapter == 'libvirt':
+ return VirtualEnvironment(deploy_struct, net_struct,
+ adapter, pxe_bridge,
+ daisy_server_info, work_dir, storage_dir)
+ else:
+ return BareMetalEnvironment(deploy_struct, net_struct,
+ adapter, pxe_bridge,
+ daisy_server_info, work_dir, storage_dir)
+
+
+class DaisyEnvironmentBase(object):
+ def __init__(self, deploy_struct, net_struct, adapter, pxe_bridge,
+ daisy_server_info, work_dir, storage_dir):
+ self.deploy_struct = deploy_struct
+ self.net_struct = net_struct
+ self.adapter = adapter
+ self.pxe_bridge = pxe_bridge
+ self.work_dir = work_dir
+ self.storage_dir = storage_dir
+ self.daisy_server_info = daisy_server_info
+ self.server = None
+ LI('Daisy Environment Initialized')
+
+ def delete_daisy_server(self):
+ delete_vm_and_disk(self.daisy_server_info['name'])
+
+ def create_daisy_server_image(self):
+ LI('Begin to create Daisy Server image')
+ script = path_join(CREATE_QCOW2_PATH, 'daisy-img-modify.sh')
+ sub_script = path_join(CREATE_QCOW2_PATH, 'centos-img-modify.sh')
+ cmd = '{script} -c {sub_script} -a {address} -g {gateway} -s {disk_size}'.format(
+ script=script,
+ sub_script=sub_script,
+ address=self.daisy_server_info['address'],
+ gateway=self.daisy_server_info['gateway'],
+ disk_size=self.daisy_server_info['disk_size'])
+ LI('Command is: ')
+ LI(' %s' % cmd)
+ # status, output = commands.getstatusoutput(cmd)
+ status = run_shell(cmd)
+ if status:
+ err_exit('Failed to create Daisy Server image')
+ if os.access(self.daisy_server_info['image'], os.R_OK):
+ os.remove(self.daisy_server_info['image'])
+ image = path_join(self.work_dir, 'daisy/centos7.qcow2')
+ shutil.move(image, self.daisy_server_info['image'])
+ LI('Daisy Server image is created %s' % self.daisy_server_info['image'])
+
+ def install_daisy(self, remote_dir, bin_file):
+ self.server = DaisyServer(self.daisy_server_info['name'],
+ self.daisy_server_info['address'],
+ self.daisy_server_info['password'],
+ remote_dir,
+ bin_file,
+ self.adapter)
+ self.server.connect()
+ self.server.install_daisy()
+
+
+class BareMetalEnvironment(DaisyEnvironmentBase):
+ def delete_old_environment(self):
+ LW('Begin to delete old environment !')
+ self.delete_daisy_server()
+ LW('Old environment cleanup finished !')
+
+ def create_daisy_server(self):
+ self.create_daisy_server_image()
+ self.create_daisy_server_vm()
+
+ def create_daisy_server_vm(self):
+ # TODO: refactor the structure of deploy.yml, add VM template param of Daisy Server
+ # add self.pxe_bridge into the vm template
+ if 'template' in self.deploy_struct:
+ # get VM name of Daisy Server from the template
+ template = self.deploy_struct['template']
+ else:
+ template = BMDEPLOY_DAISY_SERVER_VM
+
+ create_vm(template,
+ name=self.daisy_server_info['name'],
+ disk_file=self.daisy_server_info['image'])
+
+ def reboot_nodes(self, boot_dev=None):
+ # TODO: add ipmi info into deploy.yml, or read from PDF
+ address = 106
+ for node in self.deploy_struct['hosts']:
+ node['ipmiIp'] = '192.168.1.' + str(address)
+ address += 1
+ if address > 111:
+ err_exit('the ipmi address exceeds the range 106~110')
+ node['ipmiUser'] = 'zteroot'
+ node['ipmiPass'] = 'superuser'
+ ipmi_reboot_node(node['ipmiIp'], node['ipmiUser'],
+ node['ipmiPass'], boot_source=boot_dev)
+
+ def deploy(self, deploy_file, net_file):
+ self.server.prepare_cluster(deploy_file, net_file)
+ self.reboot_nodes(boot_dev='pxe')
+ self.server.prepare_host_and_pxe()
+
+ LI('The hosts number is %d' % len(self.deploy_struct['hosts']))
+ self.server.check_os_installation(len(self.deploy_struct['hosts']))
+ time.sleep(10)
+ self.server.check_openstack_installation(len(self.deploy_struct['hosts']))
+
+
+class VirtualEnvironment(DaisyEnvironmentBase):
+ def create_daisy_server_network(self):
+ net_name = create_virtual_network(VMDEPLOY_DAISY_SERVER_NET)
+ if net_name != self.pxe_bridge:
+ self.delete_virtual_network(VMDEPLOY_DAISY_SERVER_NET)
+ err_exit('Network name %s is wrong, pxe bridge is %s' % (net_name, self.pxe_bridge))
+
+ def create_daisy_server_vm(self):
+ # TODO: refactor the structure of deploy.yml, add VM template param of Daisy Server
+ # add self.pxe_bridge into the vm template
+ if 'template' in self.deploy_struct:
+ # get VM name of Daisy Server from the template
+ template = self.deploy_struct['template']
+ else:
+ template = VMDEPLOY_DAISY_SERVER_VM
+
+ create_vm(template,
+ name=self.daisy_server_info['name'],
+ disk_file=self.daisy_server_info['image'])
+
+ def create_daisy_server(self):
+ self.create_daisy_server_image()
+ self.create_daisy_server_network()
+ self.create_daisy_server_vm()
+
+ def create_virtual_node(self, node):
+ name = node['name']
+ roles = node['roles']
+ controller_size = self.deploy_struct.get('disks', {'controller': 200}).get('controller')
+ compute_size = self.deploy_struct.get('disks', {'compute': 200}).get('compute')
+ LI('Begin to create virtual node %s, roles %s' % (name, roles))
+
+ if 'CONTROLLER_LB' in roles:
+ size = controller_size
+ if 'COMPUTER' in roles:
+ size = compute_size if compute_size > controller_size else controller_size
+ template = ALL_IN_ONE_TEMPLATE
+ else:
+ template = CONTROLLER_TEMPLATE
+ else:
+ size = compute_size
+ template = COMPUTE_TEMPLATE
+
+ if 'template' in node:
+ template = node['template']
+ disk_file = path_join(self.storage_dir, name + '.qcow2')
+ # TODO: modify the sizes in deploy.yml to more than 100G
+ if size < 200:
+ size = 200
+ create_virtual_disk(disk_file, size)
+ create_vm(template, name, disk_file)
+
+ def create_nodes(self):
+ # TODO: support virtNetTemplatePath in deploy.yml
+ # and multi interfaces, not only all-in-one
+ create_virtual_network(VMDEPLOY_TARGET_NODE_NET)
+ for node in self.deploy_struct['hosts']:
+ self.create_virtual_node(node)
+ time.sleep(20)
+
+ def reboot_nodes(self, boot_devs=None):
+ for node in self.deploy_struct['hosts']:
+ reboot_vm(node['name'], boot_devs=boot_devs)
+
+ def delete_nodes(self):
+ for host in self.deploy_struct['hosts']:
+ delete_vm_and_disk(host['name'])
+
+ def delete_networks(self):
+ if 'virtNetTemplatePath' in self.deploy_struct:
+ path = self.deploy_struct['virtNetTemplatePath']
+ else:
+ path = VIRT_NET_TEMPLATE_PATH
+
+ if not os.path.isdir(path):
+ LW('Cannot find the virtual network template path %s' % path)
+ return
+ for f in os.listdir(path):
+ f = path_join(path, f)
+ if os.path.isfile(f):
+ delete_virtual_network(f)
+
+ def delete_old_environment(self):
+ LW('Begin to delete old environment !')
+ self.delete_nodes()
+ self.delete_daisy_server()
+ self.delete_networks()
+ LW('Old environment cleanup finished !')
+
+ def deploy(self, deploy_file, net_file):
+ self.server.prepare_cluster(deploy_file, net_file)
+ self.create_nodes()
+ self.server.prepare_host_and_pxe()
+ LI('Begin Daisy virtual-deploy os and openstack')
+ self.reboot_nodes()
+ LI('Sleep 20s to wait the VM(s) startup')
+ time.sleep(20)
+ self.server.install_virtual_nodes()
+
+ LI('The hosts number is %d' % len(self.deploy_struct['hosts']))
+ self.server.check_os_installation(len(self.deploy_struct['hosts']))
+ time.sleep(10)
+ self.reboot_nodes(boot_devs=['hd'])
+ self.server.check_openstack_installation(len(self.deploy_struct['hosts']))
+ self.server.post_deploy()
--- /dev/null
+##############################################################################
+# Copyright (c) 2017 ZTE Corporation and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+import commands
+import libvirt
+import os
+import xml.etree.ElementTree as ET
+
+from utils import (
+ LI,
+ LE,
+ LW,
+ WORKSPACE,
+ err_exit,
+ path_join
+)
+
+
+def get_nets_name(root):
+ nets = []
+ for interface in root.findall('./devices/interface'):
+ if 'type' in interface.attrib and interface.attrib['type'] == 'network':
+ for source in interface.iterfind('source'):
+ if 'network' in source.attrib:
+ nets.append(source.attrib['network'])
+ return nets
+
+
+def modify_vm_boot_order(root, boot_devs):
+ os_elem = root.find('os')
+ for boot_elem in os_elem.findall('boot'):
+ os_elem.remove(boot_elem)
+ for boot_dev in boot_devs:
+ boot_elem = ET.Element('boot', attrib={'dev': boot_dev})
+ os_elem.append(boot_elem)
+ return root
+
+
+def modify_vm_name(root, vm_name):
+ name_elem = root.find('./name')
+ name_elem.text = vm_name
+
+
+def modify_vm_disk_file(root, disk_file):
+ for disk in root.findall('./devices/disk'):
+ if 'device' in disk.attrib and disk.attrib['device'] == 'disk':
+ for source in disk.iterfind('source'):
+ if 'file' in source.attrib:
+ source.attrib['file'] = disk_file
+ break
+
+
+def create_virtual_disk(disk_file, size):
+ LI('Create virtual disk file %s size %d GB' % (disk_file, size))
+ cmd = 'qemu-img create -f qcow2 {disk_file} {size}G'.format(
+ disk_file=disk_file, size=size)
+ status, output = commands.getstatusoutput(cmd)
+ if status:
+ LE(output)
+ err_exit('Fail to create qemu image !')
+
+
+def create_vm(template, name=None, disk_file=None):
+ LI('Begin to create VM %s' % template)
+
+ if name or disk_file:
+ tree = ET.ElementTree(file=template)
+ root = tree.getroot()
+ if name:
+ modify_vm_name(root, name)
+ if disk_file:
+ modify_vm_disk_file(root, disk_file)
+
+ temp_file = path_join(WORKSPACE, 'tmp.xml')
+ tree.write(temp_file)
+ output = commands.getoutput('cat %s' % temp_file)
+ os.remove(temp_file)
+ else:
+ output = commands.getoutput('cat %s' % template)
+
+ conn = libvirt.open('qemu:///system')
+ domain = conn.defineXML(output)
+ if domain is None:
+ err_exit('Failed to define VM %s' % template)
+ if domain.create() < 0:
+ err_exit('Failed to start VM %s' % template)
+ domain.setAutostart(1)
+
+ LI('VM %s is started' % domain.name())
+ return
+
+
+def reboot_vm(vm_name, boot_devs=None):
+ LI('Begin to reboot VM %s', vm_name)
+ conn = libvirt.open('qemu:///system')
+ try:
+ vm = conn.lookupByName(vm_name)
+ except libvirt.libvirtError as e:
+ LE(e)
+ err_exit('VM %s is not found: ' % vm_name)
+
+ if boot_devs:
+ if vm.isActive():
+ vm.destroy()
+ LI('Destroy VM %s' % vm_name)
+
+ # root = ET.fromstring(vm.XMLDesc())
+ temp_file = path_join(WORKSPACE, 'tmp.xml')
+ commands.getoutput('virsh dumpxml %s > %s' % (vm_name, temp_file))
+ tree = ET.parse(temp_file)
+ root = tree.getroot()
+ LI('Modify the boot order %s' % boot_devs)
+ modify_vm_boot_order(root, boot_devs)
+ tree.write(temp_file)
+
+ LI('Re-define and start the VM %s' % vm_name)
+ vm.undefine()
+ vm = conn.defineXML(commands.getoutput('cat %s' % temp_file))
+ vm.create()
+ vm.setAutostart(1)
+ else:
+ vm.reset()
+
+ conn.close()
+
+
+def get_disk_file(root):
+ disks = []
+ for disk in root.findall('./devices/disk'):
+ if 'device' in disk.attrib and disk.attrib['device'] == 'disk':
+ for source in disk.iterfind('source'):
+ if 'file' in source.attrib:
+ disks.append(source.attrib['file'])
+ return disks
+
+
+def delete_vm_and_disk(vm_name):
+ LI('Begin to delete VM %s', vm_name)
+ conn = libvirt.open('qemu:///system')
+ vm = None
+ for item in conn.listAllDomains():
+ if vm_name == item.name():
+ vm = item
+ break
+ if vm is None:
+ conn.close()
+ LI('VM %s is not found' % vm_name)
+ return
+
+ output = vm.XMLDesc()
+ root = ET.fromstring(output)
+
+ if vm.isActive():
+ vm.destroy()
+ LI('Destroy VM %s' % vm.name())
+ vm.undefine()
+
+ for disk_file in get_disk_file(root):
+ if os.path.isfile(disk_file):
+ status, output = commands.getstatusoutput('rm -f %s' % disk_file)
+ if status:
+ LW('Failed to delete the VM disk file %s' % disk_file)
+
+ conn.close()
+ LI('VM %s is removed' % vm_name)
+
+
+def create_virtual_network(template):
+ LI('Begin to create virtual network %s' % template)
+ output = commands.getoutput('cat %s' % template)
+ conn = libvirt.open('qemu:///system')
+ network = conn.networkDefineXML(output)
+ if network is None:
+ err_exit('Failed to define a virtual network %s' % template)
+
+ network.create() # set the network active
+ network.setAutostart(1)
+ conn.close()
+ LI('Virtual network %s is created' % network.name())
+ return network.name()
+
+
+def delete_virtual_network(network_xml):
+ LI('Begin to find and delete network %s' % network_xml)
+ tree = ET.ElementTree(file=network_xml)
+ root = tree.getroot()
+ names = root.findall('./name')
+ assert len(names) == 1
+ name = names[0].text
+
+ result = 0
+ conn = libvirt.open('qemu:///system')
+
+ for net in conn.listAllNetworks():
+ if name == net.name():
+ if net.isActive():
+ net.destroy()
+ LI('Network %s is destroyed' % name)
+ net.undefine()
+ LI('Network %s is deleted' % name)
+ result = 1
+ break
+ conn.close()
+ if not result:
+ LI('Network %s is not found' % name)
--- /dev/null
+##############################################################################
+# Copyright (c) 2017 ZTE Corporation and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+import commands
+from configobj import ConfigObj
+import os
+import logging
+import subprocess
+import sys
+
+
+path_join = os.path.join
+CWD = os.getcwd()
+WORKSPACE = os.path.normpath(path_join(os.path.dirname(__file__), '..'))
+BASE = CWD
+
+
+def get_logger():
+ logger = logging.getLogger(__name__)
+ logger.setLevel(logging.DEBUG)
+ formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+ handler = logging.StreamHandler(sys.stdout)
+ handler.setFormatter(formatter)
+ logger.addHandler(handler)
+ return logger
+
+
+LOG = get_logger()
+LD = LOG.debug
+LI = LOG.info
+LW = LOG.warn
+LE = LOG.error
+
+
+def save_log_to_file(log_file):
+ with open(log_file, 'w+'):
+ pass
+
+ formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+ handler = logging.FileHandler(log_file, mode='w')
+ handler.setFormatter(formatter)
+ LOG.addHandler(handler)
+
+
+def err_exit(message):
+ LE('%s\n' % message)
+ sys.exit(1)
+
+
+def log_bar(message, log_func=LI):
+ bar = '=' * len(message)
+ log_func(bar)
+ log_func(message)
+ log_func(bar)
+
+
+def check_sudo_privilege():
+ uid = os.getuid()
+ if uid != 0:
+ err_exit('You need run this script with sudo privilege')
+
+
+def check_file_exists(file_path):
+ if not os.path.dirname(file_path):
+ file_path = os.path.normpath(path_join(BASE, file_path))
+ if not os.access(file_path, os.R_OK):
+ err_exit('File %s not found\n' % file_path)
+
+
+def make_file_executable(file_path):
+ if not os.path.isdir(file_path):
+ file_path = os.path.normpath(path_join(BASE, file_path))
+ if not os.access(file_path, os.R_OK):
+ err_exit('File %s not found\n' % file_path)
+ if not os.access(file_path, os.X_OK):
+ LW('File %s is not executable, chmod it and continue' % file_path)
+ status, output = commands.getstatusoutput('chmod +x %s' % file_path)
+ if status:
+ err_exit('Cannot change the file mode of %s' % file_path)
+
+
+def confirm_dir_exists(dir_path):
+ if not os.path.isdir(dir_path):
+ LI('Creating directory %s' % dir_path)
+ os.makedirs(dir_path)
+
+
+def update_config(conf_file, key, value, section='DEFAULT'):
+ LI('Update_config [ %s : %s ] to file: %s' % (key, value, conf_file))
+ config = ConfigObj(conf_file)
+ config[section][key] = value
+ config.write()
+
+
+def ipmi_reboot_node(host, user, passwd, boot_source=None):
+ prefix = 'ipmitool -I lanplus -H {host} -U {user} -P {passwd} -R 1 '.format(
+ host=host, user=user, passwd=passwd)
+ if boot_source:
+ cmd = prefix + 'chassis bootdev {boot_source}'.format(boot_source=boot_source)
+ LI('IMPI set node %s boot from %s' % (host, boot_source))
+ status, output = commands.getstatusoutput(cmd)
+ if status:
+ err_exit('IPMI command failed: %s' % output)
+
+ cmd = prefix + 'chassis power reset'
+ LI('IPMI reset node %s' % host)
+ status, output = commands.getstatusoutput(cmd)
+ if status:
+ err_exit('IPMI command failed: %s' % output)
+
+
+def run_shell(cmd, check=False):
+ process = subprocess.Popen(cmd,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ shell=True)
+ while process.poll() is None:
+ LD(process.stdout.readline().strip())
+
+ response, stderr = process.communicate()
+ return_code = process.returncode
+
+ if check:
+ if return_code > 0:
+ stderr = stderr.strip()
+ LE('Failed command: ' + str(cmd))
+ LE('Command returned error: ' + str(stderr))
+ err_exit('Command return code: ' + str(return_code))
+ else:
+ LI('Successful command: ' + str(cmd))
+
+ return return_code
+configobj
+paramiko
+pyyaml
+scp
+configobj
+paramiko
+pyyaml
+scp
pytest
pytest-cov
pytest-faker
Code Review / daisy.git / commitdiff