import sys
import re
from pymongo import MongoClient
# Determine BigRobot path(s) based on this executable (which resides in
# the bin/ directory.
bigrobot_path = os.path.dirname(__file__) + '/..'
exscript_path = bigrobot_path + '/vendors/exscript/src'
sys.path.insert(0, bigrobot_path)
sys.path.insert(1, exscript_path)
import autobot.helpers as helpers
helpers.set_env('IS_GOBOT', 'False')
helpers.set_env('AUTOBOT_LOG', './myrobot.log')
if not 'BUILD_NAME' in os.environ:
helpers.error_exit("Environment variable BUILD_NAME is not defined.", 1)
configs = helpers.bigrobot_config_test_catalog()
db_server = configs['db_server']
db_port = configs['db_port']
database = configs['database']
client = MongoClient(db_server, db_port)
db = client[database]
testsuites = db.test_suites
import os
import sys
import robot
# Special settings for the task server, not intended for execution on client.
if ('BIGROBOT_ESB' in os.environ
and os.environ['BIGROBOT_ESB'].lower() == 'true'):
bigrobot_path = os.path.dirname(__file__) + '/../..'
sys.path.insert(0, bigrobot_path + '/vendors/exscript/src')
# sys.path.insert(0, bigrobot_path + '/vendors/paramiko')
sys.path.insert(0, bigrobot_path + '/esb')
sys.path.insert(0, bigrobot_path)
import autobot.helpers as helpers
helpers.set_env('IS_GOBOT', 'False')
helpers.bigrobot_path(bigrobot_path)
helpers.bigrobot_log_path('/tmp/bigrobot_esb_log')
helpers.bigrobot_log_path_exec_instance(
helpers.bigrobot_log_path() + "/" +
os.path.dirname(__file__).split('/')[-1])
helpers.set_env(
'AUTOBOT_LOG',
helpers.bigrobot_log_path_exec_instance() + "/bigrobot_autobot.log")
def vm_setup(self, **kwargs):
result = {
"status_code": True,
"status_descr": "Success",
}
try:
vm_name = kwargs.get("vm_name", None)
kvm_host = kwargs.get("kvm_host", KVM_SERVER)
kvm_user = kwargs.get("kvm_user", KVM_USER)
kvm_password = kwargs.get("kvm_password", KVM_PASSWORD)
vm_host_name = kwargs.get("vm_host_name", None)
vm_type = kwargs.get("vm_type", "bcf")
qcow_path = kwargs.get("qcow_path", None)
qcow_vm_path = None
ip = kwargs.get("ip", None)
vm_ram = kwargs.get("vm_ram", "2048")
build_number = kwargs.get("build_number", None)
if ip == 'None':
ip = None
cluster_ip = kwargs.get("cluster_ip", None)
netmask = kwargs.get("netmask", "18")
gateway = kwargs.get("gateway", "10.8.0.1")
network_interface = kwargs.get("network_interface", "br0")
self.log_path = LOG_BASE_PATH + '/' + vm_name
try:
if os.path.exists(self.log_path) or os.path.islink(
self.log_path):
pass
else:
os.makedirs(self.log_path)
except OSError as exc: # Python >2.5
if exc.errno == errno.EEXIST and os.path.isdir(LOG_BASE_PATH):
pass
else:
# Last resort - put logs in /tmp
self.log_path = '/tmp' + '/' + vm_name
os.makedirs(self.log_path)
# export IS_GOBOT="False"
helpers.set_env("AUTOBOT_LOG",
"%s/%s.log" % (self.log_path, vm_name))
helpers.bigrobot_log_path_exec_instance(self.log_path)
# Note: helpers.summary_log() and helpers.log() are not called
# until after we've initialized the BigRobot log path
# (above). Don't attempt to write to logs before that
# or it will write logs to /tmp directory instead of the
# /tmp/<vm_name>/.
helpers.summary_log("Creating VM with Name: %s " % vm_name)
helpers.summary_log("Created log_path %s" % self.log_path)
# remote_qcow_bvs_path = kwargs.get("remote_qcow_bvs_path", "/var/lib/jenkins/jobs/bvs\ master/lastSuccessful/archive/target/appliance/images/bcf/controller-bcf-2.0.8-SNAPSHOT.qcow2")
remote_qcow_bvs_path = kwargs.get(
"remote_qcow_bvs_path",
"/var/lib/jenkins/jobs/bcf_master/lastSuccessful/archive/controller-bcf-*.qcow2"
)
remote_qcow_mininet_path = kwargs.get(
"remote_qcow_mininet_path",
"/var/lib/jenkins/jobs/t6-mininet-vm/builds/lastSuccessfulBuild/archive/t6-mininet-vm/ubuntu-kvm/t6-mininet.qcow2"
)
topo_file = self._create_temp_topo(kvm_host=kvm_host,
vm_name=vm_name)
# set the BIG ROBOT Topo file for console connections
helpers.bigrobot_topology(topo_file)
helpers.bigrobot_params("none")
kvm_handle = self._connect_to_kvm_host(hostname=kvm_host,
user=kvm_user,
password=kvm_password)
if vm_name in kvm_handle.bash('sudo virsh list --all')['content']:
helpers.summary_log(
"VM with given name %s already exists in KVM Host %s" %
(vm_name, kvm_host))
return False
if qcow_path is not None:
helpers.log(
"QCOW path is provided using it locally NO SCP just copy to images.."
)
qcow_vm_path = self._cp_qcow_to_images_folder(
kvm_handle=kvm_handle,
qcow_path=qcow_path,
vm_name=vm_name)
else:
helpers.log(
"no VMDK path is given copying from latest bvs build from jenkins server"
)
if vm_type == 'mininet':
helpers.log(
"Scp'ing Latest Mininet qcow file from jenkins to kvm Host.."
)
qcow_vm_path = self._scp_file_to_kvm_host(
kvm_handle=kvm_handle,
remote_qcow_path=remote_qcow_mininet_path,
vm_type='mininet',
vm_name=vm_name,
build_number=build_number)
else:
helpers.log(
"Scp'ing Latest BVS qcow file %s from jenkins to kvm Host.."
% remote_qcow_bvs_path)
qcow_vm_path = self._scp_file_to_kvm_host(
kvm_handle=kvm_handle,
remote_qcow_path=remote_qcow_bvs_path,
vm_name=vm_name,
build_number=build_number)
helpers.log("Creating VM on KVM Host with Name : %s " % vm_name)
self.create_vm_on_kvm_host(vm_type=vm_type,
qcow_path=qcow_vm_path,
vm_name=vm_name,
kvm_handle=kvm_handle,
kvm_host=kvm_host,
network_interface=network_interface,
vm_ram=vm_ram)
result['vm_name'] = vm_name
result['kvm_host'] = kvm_host
result['image_path'] = qcow_vm_path
result['vm_ip'] = ip
# result['content'] = helpers.file_read_once("%s/%s.log"
# % (self.log_path,
# vm_name))
if vm_type == 'mininet':
# FIX ME configure mininet with user specified ip / return the DHCP ip of mininet VM
helpers.log("Success Creating Mininet vm!!")
helpers.log("Configuring IP for mininet if provided")
result['vm_ip'] = self.set_mininet_ip(node="c1",
ip=ip,
get_ip=True)
return result
# For controller, attempt First Boot
helpers.log("SLeep another 60 sec for controller to boot up..")
time.sleep(30)
result['vm_ip'] = self._configure_vm_first_boot(
cluster_ip=cluster_ip,
ip_address=ip,
netmask=netmask,
vm_host_name=vm_host_name,
gateway=gateway)
helpers.summary_log(
"Copying firstboot-config on New Controller: %s" %
result['vm_ip'])
helpers.sleep(10)
bvs = ControllerDevConf(host=result['vm_ip'],
user="******",
password="******",
name="test-bvs")
bvs.config("copy running-config snapshot://firstboot-config")
helpers.summary_log("Success saving firstboot-config")
helpers.summary_log("Done! Logs are written to %s" % self.log_path)
return result
except:
inst = helpers.exception_info_traceback()
helpers.log("Exception Details:\n%s" % inst)
result['status_code'] = False
result['status_descr'] = inst
return result
import random
# Derive BigRobot path from the script's location, which should be
# in the bigrobot/test directory.
bigrobot_path = os.path.dirname(__file__) + '/..'
exscript_path = bigrobot_path + '/vendors/exscript/src'
sys.path.insert(0, exscript_path)
sys.path.insert(0, bigrobot_path)
import autobot.helpers as helpers
import autobot.setup_env as setup_env
from autobot.nose_support import run, log_to_console, sleep, Singleton
from keywords.BsnCommon import BsnCommon
from keywords.T5Torture import T5Torture
helpers.set_env('BIGROBOT_TEST_POSTMORTEM', 'False', quiet=True)
helpers.set_env('BIGROBOT_TEST_SETUP', 'False', quiet=True)
helpers.set_env('BIGROBOT_TEST_CLEAN_CONFIG', 'False', quiet=True)
helpers.set_env('BIGROBOT_TEST_TEARDOWN', 'False', quiet=True)
helpers.remove_env('BIGROBOT_TOPOLOGY', quiet=True)
# Test suite is defined as the name of the test script minus its extension.
helpers.bigrobot_suite(os.path.basename(__file__).split('.')[0])
setup_env.standalone_environment_setup()
assert helpers.bigrobot_path() != None
assert helpers.bigrobot_log_path_exec_instance() != None
assert helpers.bigrobot_suite() != None
helpers.print_bigrobot_env(minimum=True)
class TestBcfEvents:
def _scp_file_to_kvm_host(self,
vm_name=None,
remote_qcow_path=None,
kvm_handle=None,
vm_type="bcf",
build_number=None,
scp=True):
# for getting the latest jenkins build from jenkins server kvm_host ssh key should be copied to jenkins server
output = kvm_handle.bash('uname -a')
helpers.log("KVM Host Details : \n %s" % output['content'])
kvm_handle.bash('cd /var/lib/libvirt/')
helpers.log(" GOT VM_TYPE : %s" % vm_type)
if "No such file or directory" in kvm_handle.bash(
'cd bvs_images/')['content']:
helpers.log(
"No BVS_IMAGES dir in KVM Host @ /var/lib/libvirt creating one to store bvs vmdks"
)
kvm_handle.bash('sudo mkdir bvs_images')
kvm_handle.bash('sudo chmod -R 777 bvs_images/')
else:
helpers.log(
'BVS_IMAGES dir exists in KVM Host @ /var/lib/libvirt/bvs_images/ copying latest vmdkd from jenkins server'
)
kvm_handle.bash('sudo chmod -R 777 ../bvs_images/')
kvm_handle.bash('cd bvs_images')
helpers.log("Latest VMDK will be copied to location : %s at KVM Host" %
kvm_handle.bash('pwd')['content'])
helpers.log("Executing Scp cmd to copy latest bvs vmdk to KVM Server")
jenkins_project_name = None
if remote_qcow_path is not None:
match = re.match(r'/var/lib/jenkins/jobs/(.*)/lastSuccessful/',
remote_qcow_path)
if match:
jenkins_project_name = match.group(1)
helpers.summary_log("Using Jenkins Project Name: %s" %
jenkins_project_name)
latest_build_number = self._get_latest_jenkins_build_number(
vm_type, jenkins_project_name=jenkins_project_name)
latest_kvm_build_number = self._get_latest_kvm_build_number(
vm_type, kvm_handle, jenkins_project_name=jenkins_project_name)
if build_number is not None:
helpers.log(
"Build Number is provided resetting latest builds to %s" %
build_number)
latest_build_number = build_number
latest_kvm_build_number = build_number
file_name = None
if vm_type == 'bcf':
if jenkins_project_name == "bcf_master":
file_name = "controller-jf_bcf_virtual-%s.qcow2" % (
latest_build_number)
else:
file_name = "controller-%s_virtual-%s.qcow2" % (
jenkins_project_name, latest_build_number)
helpers.log("Adding virtual tag to build file Name : %s" %
file_name)
elif vm_type == 'mininet':
file_name = "mininet-%s.qcow2" % latest_build_number
helpers.log("Latest Build Number on KVM Host: %s" %
latest_kvm_build_number)
helpers.log("Latest Build Number on Jenkins: %s" % latest_build_number)
if str(latest_kvm_build_number) == str(latest_build_number) and scp:
helpers.log(
"Skipping SCP as the latest build on jenkins server did not change from the latest on KVM Host"
)
else:
scp_cmd = (
'scp -o "UserKnownHostsFile=/dev/null" -o StrictHostKeyChecking=no "%s@%s:%s" %s'
% (JENKINS_USER, JENKINS_SERVER, remote_qcow_path, file_name))
helpers.log("SCP command arguments:\n%s" % scp_cmd)
scp_cmd_out = kvm_handle.bash(
scp_cmd, prompt=[r'.*password:'******'.*#', r'.*$ '])['content']
if "password" in scp_cmd_out:
helpers.log("sending bsn password..")
helpers.log(kvm_handle.bash('bsn')['content'])
else:
helpers.log("SCP should be done:\n%s" % scp_cmd_out)
helpers.summary_log("Success SCP'ing latest Jenkins build !!")
helpers.summary_log("Using Jenkins Build #%s (image name: '%s')" %
(latest_build_number, file_name))
helpers.log("Setting BUILD_NUM Env...")
helpers.set_env("BUILD_NUM", str(latest_build_number))
helpers.log("env BUILD_NUM: %s" % helpers.get_env("BUILD_NUM"))
kvm_handle.bash('sudo cp %s ../images/%s.qcow2' % (file_name, vm_name))
local_qcow_path = "/var/lib/libvirt/images/%s.qcow2" % vm_name
# vm_name = "%s_BVS" % current_user
return local_qcow_path
