mirror of https://github.com/apache/cloudstack.git
1267 lines
57 KiB
Python
1267 lines
57 KiB
Python
# Licensed to the Apache Software Foundation (ASF) under one
|
|
# or more contributor license agreements. See the NOTICE file
|
|
# distributed with this work for additional information
|
|
# regarding copyright ownership. The ASF licenses this file
|
|
# to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance
|
|
# with the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing,
|
|
# software distributed under the License is distributed on an
|
|
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
# KIND, either express or implied. See the License for the
|
|
# specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
@Desc :
|
|
class DeployDataCenters: Deploys DeleteDataCenters according to a json
|
|
configuration file.
|
|
class DeleteDataCenters: Deletes a DataCenter based upon the dc cfg
|
|
settings provided.
|
|
This settings file is the exported
|
|
configuration from DeployDataCenters post
|
|
its success
|
|
"""
|
|
from marvin import configGenerator
|
|
from marvin.cloudstackException import (
|
|
InvalidParameterException,
|
|
GetDetailExceptionInfo)
|
|
from marvin.cloudstackAPI import *
|
|
from marvin.codes import (FAILED, SUCCESS)
|
|
from marvin.lib.utils import (random_gen)
|
|
from marvin.config.test_data import test_data
|
|
from sys import exit
|
|
import os
|
|
import errno
|
|
import pickle
|
|
from time import sleep, strftime, localtime
|
|
from optparse import OptionParser
|
|
|
|
|
|
class DeployDataCenters(object):
|
|
|
|
'''
|
|
@Desc : Deploys the Data Center with information provided.
|
|
Once the Deployment is successful, it will export
|
|
the DataCenter settings to an obj file
|
|
( can be used if wanted to delete the created DC)
|
|
'''
|
|
|
|
def __init__(self,
|
|
test_client,
|
|
cfg,
|
|
logger=None,
|
|
log_folder_path=None
|
|
):
|
|
self.__testClient = test_client
|
|
self.__config = cfg
|
|
self.__tcRunLogger = logger
|
|
self.__logFolderPath = log_folder_path
|
|
self.__apiClient = None
|
|
self.__cleanUp = {}
|
|
|
|
def __persistDcConfig(self):
|
|
try:
|
|
if self.__logFolderPath:
|
|
dc_file_path = os.path.join(self.__logFolderPath, "dc_entries.obj")
|
|
else:
|
|
ts = strftime("%b_%d_%Y_%H_%M_%S", localtime())
|
|
dc_file_path = "dc_entries_" + str(ts) + ".obj"
|
|
|
|
file_to_write = open(dc_file_path, 'wb')
|
|
if file_to_write:
|
|
pickle.dump(self.__cleanUp, file_to_write, protocol=0)
|
|
print("\n=== Data Center Settings are dumped to %s===" % dc_file_path)
|
|
self.__tcRunLogger.debug("\n=== Data Center Settings are dumped to %s===" % dc_file_path)
|
|
except Exception as e:
|
|
print("Exception Occurred while persisting DC Settings: %s" % \
|
|
GetDetailExceptionInfo(e))
|
|
|
|
def __cleanAndExit(self):
|
|
try:
|
|
print("\n===deploy dc failed, so cleaning the created entries===")
|
|
if not test_data.get("deleteDC", None):
|
|
print("\n=== Deploy DC Clean Up flag not set. So, exiting ===")
|
|
exit(1)
|
|
self.__tcRunLogger.debug(
|
|
"===Deploy DC Failed, So Cleaning to Exit===")
|
|
remove_dc_obj = DeleteDataCenters(self.__testClient,
|
|
dc_cfg=self.__cleanUp,
|
|
tc_run_logger=self.__tcRunLogger
|
|
)
|
|
if remove_dc_obj:
|
|
if remove_dc_obj.removeDataCenter() == FAILED:
|
|
print("\n===Removing DataCenter Failed===")
|
|
self.__tcRunLogger.debug(
|
|
"===Removing DataCenter Failed===")
|
|
else:
|
|
print("\n===Removing DataCenter Successful===")
|
|
self.__tcRunLogger.debug(
|
|
"===Removing DataCenter Successful===")
|
|
exit(1)
|
|
except Exception as e:
|
|
print("Exception Occurred during DC CleanUp: %s" % \
|
|
GetDetailExceptionInfo(e))
|
|
|
|
def __addToCleanUp(self, type, id):
|
|
if type not in list(self.__cleanUp.keys()):
|
|
self.__cleanUp[type] = []
|
|
self.__cleanUp[type].append(id)
|
|
if "order" not in list(self.__cleanUp.keys()):
|
|
self.__cleanUp["order"] = []
|
|
if type not in self.__cleanUp["order"]:
|
|
self.__cleanUp["order"].append(type)
|
|
|
|
def addHosts(self, hosts, zoneId, podId, clusterId, hypervisor):
|
|
if hosts is None:
|
|
print("\n === Invalid Hosts Information ====")
|
|
return
|
|
failed_cnt = 0
|
|
for host in hosts:
|
|
try:
|
|
hostcmd = addHost.addHostCmd()
|
|
hostcmd.clusterid = clusterId
|
|
hostcmd.hosttags = host.hosttags
|
|
hostcmd.hypervisor = host.hypervisor
|
|
hostcmd.password = host.password
|
|
hostcmd.podid = podId
|
|
hostcmd.url = host.url
|
|
hostcmd.username = host.username
|
|
hostcmd.zoneid = zoneId
|
|
hostcmd.hypervisor = hypervisor
|
|
if hostcmd.hypervisor.lower() == "baremetal":
|
|
hostcmd.hostmac=host.hostmac
|
|
hostcmd.cpunumber=host.cpunumber
|
|
hostcmd.cpuspeed=host.cpuspeed
|
|
hostcmd.memory=host.memory
|
|
hostcmd.hosttags=host.hosttags
|
|
ret = self.__apiClient.addHost(hostcmd)
|
|
if ret:
|
|
self.__tcRunLogger.debug("=== Add Host Successful ===")
|
|
self.__addToCleanUp("Host", ret[0].id)
|
|
except Exception as e:
|
|
failed_cnt = failed_cnt + 1
|
|
print("Exception Occurred :%s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception(
|
|
"=== Adding Host Failed :%s===" % str(
|
|
host.url))
|
|
if failed_cnt == len(hosts):
|
|
self.__cleanAndExit()
|
|
continue
|
|
|
|
def addVmWareDataCenter(self, vmwareDc):
|
|
try:
|
|
vdc = addVmwareDc.addVmwareDcCmd()
|
|
vdc.zoneid = vmwareDc.zoneid
|
|
vdc.name = vmwareDc.name
|
|
vdc.vcenter = vmwareDc.vcenter
|
|
vdc.username = vmwareDc.username
|
|
vdc.password = vmwareDc.password
|
|
ret = self.__apiClient.addVmwareDc(vdc)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug("=== Adding VmWare DC Successful===")
|
|
self.__addToCleanUp("VmwareDc", ret.id)
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("=== Adding VmWare DC Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def addBaremetalRct(self, config):
|
|
networktype= config.zones[0].networktype
|
|
baremetalrcturl= config.zones[0].baremetalrcturl
|
|
if networktype is None or baremetalrcturl is None:
|
|
return
|
|
if networktype.lower()=="advanced":
|
|
|
|
try:
|
|
brctcmd = addBaremetalRct.addBaremetalRctCmd()
|
|
brctcmd.baremetalrcturl=baremetalrcturl
|
|
ret = self.__apiClient.addBaremetalRct(brctcmd)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug("=== Adding Baremetal Rct file Successful===")
|
|
self.__addToCleanUp("BaremetalRct", ret.id)
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("=== Adding Baremetal Rct file Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def createClusters(self, clusters, zoneId, podId, vmwareDc=None):
|
|
try:
|
|
if clusters is None:
|
|
return
|
|
if vmwareDc is not None:
|
|
vmwareDc.zoneid = zoneId
|
|
self.addVmWareDataCenter(vmwareDc)
|
|
|
|
for cluster in clusters:
|
|
clustercmd = addCluster.addClusterCmd()
|
|
clustercmd.clustername = cluster.clustername
|
|
clustercmd.clustertype = cluster.clustertype
|
|
clustercmd.hypervisor = cluster.hypervisor
|
|
clustercmd.password = cluster.password
|
|
clustercmd.podid = podId
|
|
clustercmd.url = cluster.url
|
|
clustercmd.username = cluster.username
|
|
clustercmd.zoneid = zoneId
|
|
clusterresponse = self.__apiClient.addCluster(clustercmd)
|
|
if clusterresponse[0].id:
|
|
clusterId = clusterresponse[0].id
|
|
self.__tcRunLogger.\
|
|
debug("Cluster Name : %s Id : %s Created Successfully"
|
|
% (str(cluster.clustername), str(clusterId)))
|
|
self.__addToCleanUp("Cluster", clusterId)
|
|
if cluster.hypervisor.lower() != "vmware":
|
|
self.addHosts(cluster.hosts, zoneId, podId, clusterId,
|
|
cluster.hypervisor)
|
|
self.waitForHost(zoneId, clusterId)
|
|
if cluster.hypervisor.lower() != "baremetal":
|
|
self.createPrimaryStorages(cluster.primaryStorages,
|
|
zoneId,
|
|
podId,
|
|
clusterId)
|
|
|
|
except Exception as e:
|
|
print("Exception Occurred %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("====Cluster %s Creation Failed"
|
|
"=====" %
|
|
str(cluster.clustername))
|
|
self.__cleanAndExit()
|
|
|
|
def waitForHost(self, zoneId, clusterId):
|
|
"""
|
|
Wait for the hosts in the zoneid, clusterid to be up
|
|
2 retries with 30s delay
|
|
"""
|
|
try:
|
|
retry, timeout = 2, 30
|
|
cmd = listHosts.listHostsCmd()
|
|
cmd.clusterid, cmd.zoneid = clusterId, zoneId
|
|
hosts = self.__apiClient.listHosts(cmd)
|
|
while retry != 0:
|
|
for host in hosts:
|
|
if host.state != 'Up':
|
|
break
|
|
sleep(timeout)
|
|
retry = retry - 1
|
|
except Exception as e:
|
|
print("\nException Occurred:%s" %\
|
|
GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("=== List Hosts Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def createPrimaryStorages(self,
|
|
primaryStorages,
|
|
zoneId,
|
|
podId=None,
|
|
clusterId=None):
|
|
try:
|
|
if primaryStorages is None:
|
|
return
|
|
for primary in primaryStorages:
|
|
primarycmd = createStoragePool.createStoragePoolCmd()
|
|
if primary.details:
|
|
for key, value in vars(primary.details).items():
|
|
primarycmd.details.append({ key: value})
|
|
primarycmd.name = primary.name
|
|
|
|
primarycmd.tags = primary.tags
|
|
primarycmd.url = primary.url
|
|
if primary.scope == 'zone' or clusterId is None:
|
|
primarycmd.scope = 'zone'
|
|
primarycmd.hypervisor = primary.hypervisor
|
|
else:
|
|
primarycmd.podid = podId
|
|
primarycmd.clusterid = clusterId
|
|
primarycmd.zoneid = zoneId
|
|
|
|
ret = self.__apiClient.createStoragePool(primarycmd)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug(
|
|
"=== Creating Storage Pool Successful===")
|
|
self.__addToCleanUp("StoragePool", ret.id)
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("=== Create Storage Pool Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def createPods(self,
|
|
pods,
|
|
zoneId,
|
|
networkId=None):
|
|
try:
|
|
if pods is None:
|
|
return
|
|
for pod in pods:
|
|
createpod = createPod.createPodCmd()
|
|
createpod.name = pod.name
|
|
createpod.gateway = pod.gateway
|
|
createpod.netmask = pod.netmask
|
|
createpod.startip = pod.startip
|
|
createpod.endip = pod.endip
|
|
createpod.zoneid = zoneId
|
|
createpodResponse = self.__apiClient.createPod(createpod)
|
|
if createpodResponse.id:
|
|
podId = createpodResponse.id
|
|
self.__tcRunLogger.debug("Pod Name : %s Id : %s "
|
|
"Created Successfully" %
|
|
(str(pod.name), str(podId)))
|
|
self.__addToCleanUp("Pod", podId)
|
|
if pod.guestIpRanges is not None and networkId is not None:
|
|
self.createVlanIpRanges("Basic", pod.guestIpRanges, zoneId,
|
|
podId, networkId)
|
|
self.createClusters(pod.clusters, zoneId, podId,
|
|
vmwareDc=pod.vmwaredc)
|
|
if self.isTungstenZone:
|
|
self.createTungstenManagementNetwork(podId)
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("====Pod: %s Creation "
|
|
"Failed=====" % str(pod.name))
|
|
self.__cleanAndExit()
|
|
|
|
def createVlanIpRanges(self, mode, ipranges, zoneId, podId=None,
|
|
networkId=None, forvirtualnetwork=None):
|
|
try:
|
|
if ipranges is None:
|
|
return
|
|
for iprange in ipranges:
|
|
vlanipcmd = createVlanIpRange.createVlanIpRangeCmd()
|
|
vlanipcmd.account = iprange.account
|
|
vlanipcmd.domainid = iprange.domainid
|
|
vlanipcmd.endip = iprange.endip
|
|
vlanipcmd.gateway = iprange.gateway
|
|
vlanipcmd.netmask = iprange.netmask
|
|
vlanipcmd.networkid = networkId
|
|
vlanipcmd.podid = podId
|
|
vlanipcmd.startip = iprange.startip
|
|
vlanipcmd.zoneid = zoneId
|
|
vlanipcmd.vlan = iprange.vlan
|
|
if mode == "Basic":
|
|
if forvirtualnetwork:
|
|
vlanipcmd.forvirtualnetwork = "true"
|
|
else:
|
|
vlanipcmd.forvirtualnetwork = "false"
|
|
else:
|
|
vlanipcmd.forvirtualnetwork = "true"
|
|
ret = self.__apiClient.createVlanIpRange(vlanipcmd)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug(
|
|
"=== Creating Vlan Ip Range Successful===")
|
|
self.__addToCleanUp("VlanIpRange", ret.id)
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("=== Create Vlan Ip Range Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def createSecondaryStorages(self, secondaryStorages, zoneId):
|
|
try:
|
|
if secondaryStorages is None:
|
|
return
|
|
for secondary in secondaryStorages:
|
|
secondarycmd = addImageStore.addImageStoreCmd()
|
|
secondarycmd.url = secondary.url
|
|
secondarycmd.provider = secondary.provider
|
|
secondarycmd.details = []
|
|
|
|
if secondarycmd.provider.lower() in ('s3', "swift", "smb"):
|
|
for key, value in vars(secondary.details).items():
|
|
secondarycmd.details.append({
|
|
'key': key,
|
|
'value': value
|
|
})
|
|
if secondarycmd.provider.lower() in ("nfs", "smb"):
|
|
secondarycmd.zoneid = zoneId
|
|
ret = self.__apiClient.addImageStore(secondarycmd)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug(
|
|
"===Add Image Store Successful===")
|
|
self.__addToCleanUp("ImageStore", ret.id)
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("=== Add Image Store Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def createCacheStorages(self, cacheStorages, zoneId):
|
|
try:
|
|
if cacheStorages is None:
|
|
return
|
|
for cache in cacheStorages:
|
|
cachecmd = createSecondaryStagingStore.\
|
|
createSecondaryStagingStoreCmd()
|
|
cachecmd.url = cache.url
|
|
cachecmd.provider = cache.provider
|
|
cachecmd.zoneid = zoneId
|
|
cachecmd.details = []
|
|
|
|
if cache.details:
|
|
for key, value in vars(cache.details).items():
|
|
cachecmd.details.append({
|
|
'key': key,
|
|
'value': value
|
|
})
|
|
ret = self.__apiClient.createSecondaryStagingStore(cachecmd)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug(
|
|
"===Creating Secondary StagingStore Successful===")
|
|
self.__addToCleanUp("SecondaryStagingStore", ret.id)
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("=== Creating "
|
|
"SecondaryStagingStorage Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def createNetworks(self, networks, zoneId):
|
|
try:
|
|
if networks is None:
|
|
return
|
|
for network in networks:
|
|
networkcmd = createNetwork.createNetworkCmd()
|
|
networkcmd.displaytext = network.displaytext
|
|
networkcmd.name = network.name
|
|
networkcmd.networkofferingid = network.networkofferingid
|
|
networkcmd.zoneid = zoneId
|
|
|
|
ipranges = network.ipranges
|
|
if ipranges:
|
|
iprange = ipranges.pop()
|
|
networkcmd.startip = iprange.startip
|
|
networkcmd.endip = iprange.endip
|
|
networkcmd.gateway = iprange.gateway
|
|
networkcmd.netmask = iprange.netmask
|
|
networkcmdresponse = self.__apiClient.createNetwork(networkcmd)
|
|
if networkcmdresponse.id:
|
|
networkId = networkcmdresponse.id
|
|
self.__tcRunLogger.\
|
|
debug("Creating Network Name : %s Id : %s Successful"
|
|
% (str(network.name), str(networkId)))
|
|
self.__addToCleanUp("Network", networkId)
|
|
return networkId
|
|
except Exception as e:
|
|
print("Exception Occurred %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("====Network : %s "
|
|
"Creation Failed=====" % str(network.name))
|
|
self.__cleanAndExit()
|
|
|
|
def createPhysicalNetwork(self, net, zoneid):
|
|
try:
|
|
phynet = createPhysicalNetwork.createPhysicalNetworkCmd()
|
|
phynet.zoneid = zoneid
|
|
phynet.name = net.name
|
|
phynet.isolationmethods = net.isolationmethods
|
|
if net.tags:
|
|
phynet.tags = net.tags
|
|
|
|
phynetwrk = self.__apiClient.createPhysicalNetwork(phynet)
|
|
if phynetwrk.id:
|
|
self.__tcRunLogger.\
|
|
debug("Creating Physical Network Name : "
|
|
"%s Id : %s Successful" % (str(phynet.name),
|
|
str(phynetwrk.id)))
|
|
self.__addToCleanUp("PhysicalNetwork", phynetwrk.id)
|
|
self.addTrafficTypes(phynetwrk.id, net.traffictypes)
|
|
return phynetwrk
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("====Physical Network "
|
|
"Creation Failed=====")
|
|
self.__cleanAndExit()
|
|
|
|
def updatePhysicalNetwork(self, networkid, state="Enabled",
|
|
vlan=None):
|
|
try:
|
|
upnet = updatePhysicalNetwork.updatePhysicalNetworkCmd()
|
|
upnet.id = networkid
|
|
upnet.state = state
|
|
if vlan:
|
|
upnet.vlan = vlan
|
|
ret = self.__apiClient.updatePhysicalNetwork(upnet)
|
|
return ret
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("====Update Physical Network Failed=====")
|
|
self.__cleanAndExit()
|
|
|
|
def enableProvider(self, provider_id):
|
|
try:
|
|
upnetprov =\
|
|
updateNetworkServiceProvider.updateNetworkServiceProviderCmd()
|
|
upnetprov.id = provider_id
|
|
upnetprov.state = "Enabled"
|
|
ret = self.__apiClient.updateNetworkServiceProvider(upnetprov)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug(
|
|
"===Update Network Service Provider Successfull===")
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception(
|
|
"====Update Network Service Provider Failed=====")
|
|
self.__cleanAndExit()
|
|
|
|
def configureProviders(self, phynetwrk, providers):
|
|
"""
|
|
We will enable the virtualrouter elements for all zones. Other
|
|
providers like NetScalers, SRX, etc are explicitly added/configured
|
|
"""
|
|
try:
|
|
for provider in providers:
|
|
pnetprov = listNetworkServiceProviders.\
|
|
listNetworkServiceProvidersCmd()
|
|
pnetprov.physicalnetworkid = phynetwrk.id
|
|
pnetprov.state = "Disabled"
|
|
pnetprov.name = provider.name
|
|
pnetprovres = self.__apiClient.listNetworkServiceProviders(
|
|
pnetprov)
|
|
if pnetprovres and len(pnetprovres) > 0:
|
|
if provider.name == 'VirtualRouter'\
|
|
or provider.name == 'VpcVirtualRouter':
|
|
vrprov = listVirtualRouterElements.\
|
|
listVirtualRouterElementsCmd()
|
|
vrprov.nspid = pnetprovres[0].id
|
|
vrprovresponse = self.__apiClient.\
|
|
listVirtualRouterElements(vrprov)
|
|
vrprovid = vrprovresponse[0].id
|
|
vrconfig = \
|
|
configureVirtualRouterElement.\
|
|
configureVirtualRouterElementCmd()
|
|
vrconfig.enabled = "true"
|
|
vrconfig.id = vrprovid
|
|
self.__apiClient.\
|
|
configureVirtualRouterElement(vrconfig)
|
|
self.enableProvider(pnetprovres[0].id)
|
|
elif provider.name == 'InternalLbVm':
|
|
internallbprov = listInternalLoadBalancerElements.\
|
|
listInternalLoadBalancerElementsCmd()
|
|
internallbprov.nspid = pnetprovres[0].id
|
|
internallbresponse = self.__apiClient.\
|
|
listInternalLoadBalancerElements(internallbprov)
|
|
internallbid = internallbresponse[0].id
|
|
internallbconfig = \
|
|
configureInternalLoadBalancerElement.\
|
|
configureInternalLoadBalancerElementCmd()
|
|
internallbconfig.enabled = "true"
|
|
internallbconfig.id = internallbid
|
|
self.__apiClient.\
|
|
configureInternalLoadBalancerElement(
|
|
internallbconfig)
|
|
self.enableProvider(pnetprovres[0].id)
|
|
elif provider.name == 'SecurityGroupProvider':
|
|
self.enableProvider(pnetprovres[0].id)
|
|
elif provider.name in ['JuniperContrailRouter',
|
|
'JuniperContrailVpcRouter']:
|
|
netprov = addNetworkServiceProvider.\
|
|
addNetworkServiceProviderCmd()
|
|
netprov.name = provider.name
|
|
netprov.physicalnetworkid = phynetwrk.id
|
|
result = self.__apiClient.addNetworkServiceProvider(netprov)
|
|
self.enableProvider(result.id)
|
|
elif provider.name in ['Netscaler', 'JuniperSRX', 'F5BigIp', 'NiciraNvp']:
|
|
netprov = addNetworkServiceProvider.\
|
|
addNetworkServiceProviderCmd()
|
|
netprov.name = provider.name
|
|
netprov.physicalnetworkid = phynetwrk.id
|
|
result = self.__apiClient.addNetworkServiceProvider(
|
|
netprov)
|
|
if result.id:
|
|
self.__tcRunLogger.\
|
|
debug("==== AddNetworkServiceProvider "
|
|
"Successful=====")
|
|
self.__addToCleanUp(
|
|
"NetworkServiceProvider",
|
|
result.id)
|
|
if provider.devices is not None:
|
|
for device in provider.devices:
|
|
if provider.name == 'Netscaler':
|
|
dev = addNetscalerLoadBalancer.\
|
|
addNetscalerLoadBalancerCmd()
|
|
dev.username = device.username
|
|
dev.password = device.password
|
|
dev.networkdevicetype = device.networkdevicetype
|
|
dev.url = configGenerator.getDeviceUrl(device)
|
|
dev.physicalnetworkid = phynetwrk.id
|
|
ret = self.__apiClient.addNetscalerLoadBalancer(
|
|
dev)
|
|
if ret.id:
|
|
self.__tcRunLogger.\
|
|
debug("==== AddNetScalerLB "
|
|
"Successful=====")
|
|
self.__addToCleanUp(
|
|
"NetscalerLoadBalancer",
|
|
ret.id)
|
|
elif provider.name == 'JuniperSRX':
|
|
dev = addSrxFirewall.addSrxFirewallCmd()
|
|
dev.username = device.username
|
|
dev.password = device.password
|
|
dev.networkdevicetype = device.networkdevicetype
|
|
dev.url = configGenerator.getDeviceUrl(device)
|
|
dev.physicalnetworkid = phynetwrk.id
|
|
ret = self.__apiClient.addSrxFirewall(dev)
|
|
if ret.id:
|
|
self.__tcRunLogger.\
|
|
debug("==== AddSrx "
|
|
"Successful=====")
|
|
self.__addToCleanUp("SrxFirewall", ret.id)
|
|
elif provider.name == 'F5BigIp':
|
|
dev = addF5LoadBalancer.addF5LoadBalancerCmd()
|
|
dev.username = device.username
|
|
dev.password = device.password
|
|
dev.networkdevicetype = device.networkdevicetype
|
|
dev.url = configGenerator.getDeviceUrl(device)
|
|
dev.physicalnetworkid = phynetwrk.id
|
|
ret = self.__apiClient.addF5LoadBalancer(dev)
|
|
if ret.id:
|
|
self.__tcRunLogger.\
|
|
debug("==== AddF5 "
|
|
"Successful=====")
|
|
self.__addToCleanUp("F5LoadBalancer", ret.id)
|
|
elif provider.name == 'NiciraNvp':
|
|
cmd = addNiciraNvpDevice.addNiciraNvpDeviceCmd()
|
|
cmd.hostname = device.hostname
|
|
cmd.username = device.username
|
|
cmd.password = device.password
|
|
cmd.transportzoneuuid = device.transportzoneuuid
|
|
cmd.physicalnetworkid = phynetwrk.id
|
|
ret = self.__apiClient.addNiciraNvpDevice(cmd)
|
|
self.__tcRunLogger.\
|
|
debug("==== AddNiciraNvp Successful =====")
|
|
self.__addToCleanUp("NiciraNvp", ret.id)
|
|
else:
|
|
raise InvalidParameterException(
|
|
"Device %s doesn't match "
|
|
"any know provider "
|
|
"type" % device)
|
|
self.enableProvider(result.id)
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("====List Network "
|
|
"Service Providers Failed=====")
|
|
self.__cleanAndExit()
|
|
|
|
def addTrafficTypes(self, physical_network_id, traffictypes):
|
|
[self.addTrafficType(physical_network_id, traffic_type)
|
|
for traffic_type in traffictypes]
|
|
|
|
def addTrafficType(self, physical_network_id, traffictype):
|
|
try:
|
|
traffic_type = addTrafficType.addTrafficTypeCmd()
|
|
traffic_type.physicalnetworkid = physical_network_id
|
|
traffic_type.traffictype = traffictype.typ
|
|
traffic_type.kvmnetworklabel = traffictype.kvm\
|
|
if traffictype.kvm is not None else None
|
|
traffic_type.xennetworklabel = traffictype.xen\
|
|
if traffictype.xen is not None else None
|
|
traffic_type.vmwarenetworklabel = traffictype.vmware\
|
|
if traffictype.vmware is not None else None
|
|
traffic_type.simulatorlabel = traffictype.simulator\
|
|
if traffictype.simulator is not None else None
|
|
ret = self.__apiClient.addTrafficType(traffic_type)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug("===Add TrafficType Successful====")
|
|
self.__addToCleanUp("TrafficType", ret.id)
|
|
return ret
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("==== Add TrafficType Failed=====")
|
|
self.__cleanAndExit()
|
|
|
|
def enableZone(self, zoneid, allocation_state="Enabled"):
|
|
try:
|
|
zoneCmd = updateZone.updateZoneCmd()
|
|
zoneCmd.id = zoneid
|
|
zoneCmd.allocationstate = allocation_state
|
|
ret = self.__apiClient.updateZone(zoneCmd)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug("==== Enable Zone SuccessFul=====")
|
|
return ret
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("==== Enable Zone Failed=====")
|
|
self.__cleanAndExit()
|
|
|
|
def updateZoneDetails(self, zoneid, details):
|
|
try:
|
|
zoneCmd = updateZone.updateZoneCmd()
|
|
zoneCmd.id = zoneid
|
|
zoneCmd.details = details
|
|
ret = self.__apiClient.updateZone(zoneCmd)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug("=== Update Zone SuccessFul===")
|
|
return ret
|
|
except Exception as e:
|
|
print("Exception Occurred: %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("==== Update Zone Failed=====")
|
|
self.__cleanAndExit()
|
|
|
|
def createZone(self, zone, rec=0):
|
|
try:
|
|
zoneresponse = self.__apiClient.createZone(zone)
|
|
if zoneresponse.id:
|
|
self.__addToCleanUp("Zone", zoneresponse.id)
|
|
self.__tcRunLogger.\
|
|
debug("Zone Name : %s Id : %s Created Successfully" %
|
|
(str(zone.name), str(zoneresponse.id)))
|
|
return zoneresponse.id
|
|
else:
|
|
self.__tcRunLogger.\
|
|
exception("====Zone : %s Creation Failed=====" %
|
|
str(zone.name))
|
|
print("\n====Zone : %s Creation Failed=====" % str(zone.name))
|
|
if not rec:
|
|
zone.name = zone.name + "_" + random_gen()
|
|
self.__tcRunLogger.\
|
|
debug("====Recreating Zone With New Name : "
|
|
"%s" % zone.name)
|
|
print("\n====Recreating Zone With New Name ====", \
|
|
str(zone.name))
|
|
return self.createZone(zone, 1)
|
|
except Exception as e:
|
|
print("\nException Occurred under createZone : %s" % \
|
|
GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("====Create Zone Failed ===")
|
|
return FAILED
|
|
|
|
def createZones(self, zones):
|
|
try:
|
|
for zone in zones:
|
|
zonecmd = createZone.createZoneCmd()
|
|
zonecmd.dns1 = zone.dns1
|
|
zonecmd.dns2 = zone.dns2
|
|
zonecmd.internaldns1 = zone.internaldns1
|
|
zonecmd.internaldns2 = zone.internaldns2
|
|
zonecmd.name = zone.name
|
|
zonecmd.securitygroupenabled = zone.securitygroupenabled
|
|
zonecmd.localstorageenabled = zone.localstorageenabled
|
|
zonecmd.networktype = zone.networktype
|
|
zonecmd.domain = zone.domain
|
|
if zone.securitygroupenabled != "true":
|
|
zonecmd.guestcidraddress = zone.guestcidraddress
|
|
zoneId = self.createZone(zonecmd)
|
|
if zoneId == FAILED:
|
|
self.__tcRunLogger.\
|
|
exception(
|
|
"====Zone: %s Creation Failed. So Exiting=====" %
|
|
str(zone.name))
|
|
self.__cleanAndExit()
|
|
self.isTungstenZone = False
|
|
for pnet in zone.physical_networks:
|
|
phynetwrk = self.createPhysicalNetwork(pnet, zoneId)
|
|
self.configureProviders(phynetwrk, pnet.providers)
|
|
self.updatePhysicalNetwork(phynetwrk.id, "Enabled",
|
|
vlan=pnet.vlan)
|
|
if "TF" in pnet.isolationmethods:
|
|
self.isTungstenZone = True
|
|
self.configureTungstenService(zoneId, phynetwrk.id, zone.tungstenprovider)
|
|
if zone.securitygroupenabled:
|
|
self.enableTungstenProvider(zoneId, phynetwrk.id)
|
|
|
|
if zone.networktype == "Basic":
|
|
listnetworkoffering =\
|
|
listNetworkOfferings.listNetworkOfferingsCmd()
|
|
listnetworkoffering.name =\
|
|
"DefaultSharedNetscalerEIPandELBNetworkOffering" \
|
|
if len([x for x in zone.physical_networks[0].
|
|
traffictypes if x.typ == 'Public']) > 0 \
|
|
else "DefaultSharedNetworkOfferingWithSGService"
|
|
if zone.networkofferingname is not None:
|
|
listnetworkoffering.name = zone.networkofferingname
|
|
listnetworkofferingresponse = \
|
|
self.__apiClient.listNetworkOfferings(
|
|
listnetworkoffering)
|
|
guestntwrk = configGenerator.network()
|
|
guestntwrk.displaytext = "guestNetworkForBasicZone"
|
|
guestntwrk.name = "guestNetworkForBasicZone"
|
|
guestntwrk.zoneid = zoneId
|
|
guestntwrk.networkofferingid = \
|
|
listnetworkofferingresponse[0].id
|
|
networkid = self.createNetworks([guestntwrk], zoneId)
|
|
self.createPods(zone.pods, zoneId, networkid)
|
|
if self.isEipElbZone(zone):
|
|
self.createVlanIpRanges(
|
|
zone.networktype, zone.ipranges,
|
|
zoneId, forvirtualnetwork=True)
|
|
isPureAdvancedZone = (zone.networktype == "Advanced"
|
|
and zone.securitygroupenabled != "true")
|
|
if isPureAdvancedZone:
|
|
self.createPods(zone.pods, zoneId)
|
|
self.createVlanIpRanges(zone.networktype, zone.ipranges,
|
|
zoneId)
|
|
if self.isTungstenZone:
|
|
self.createTungstenPublicNetwork(zoneId)
|
|
elif (zone.networktype == "Advanced"
|
|
and zone.securitygroupenabled == "true"):
|
|
listnetworkoffering =\
|
|
listNetworkOfferings.listNetworkOfferingsCmd()
|
|
listnetworkoffering.name =\
|
|
"DefaultSharedNetworkOfferingWithSGService"
|
|
if zone.networkofferingname is not None:
|
|
listnetworkoffering.name = zone.networkofferingname
|
|
listnetworkofferingresponse = \
|
|
self.__apiClient.listNetworkOfferings(
|
|
listnetworkoffering)
|
|
networkcmd = createNetwork.createNetworkCmd()
|
|
networkcmd.displaytext = "Shared SG enabled network"
|
|
networkcmd.name = "Shared SG enabled network"
|
|
networkcmd.networkofferingid =\
|
|
listnetworkofferingresponse[0].id
|
|
networkcmd.zoneid = zoneId
|
|
ipranges = zone.ipranges
|
|
if ipranges:
|
|
iprange = ipranges.pop()
|
|
networkcmd.startip = iprange.startip
|
|
networkcmd.endip = iprange.endip
|
|
networkcmd.gateway = iprange.gateway
|
|
networkcmd.netmask = iprange.netmask
|
|
networkcmd.vlan = iprange.vlan
|
|
networkcmdresponse = self.__apiClient.createNetwork(
|
|
networkcmd)
|
|
if networkcmdresponse.id:
|
|
self.__addToCleanUp("Network", networkcmdresponse.id)
|
|
self.__tcRunLogger.\
|
|
debug("create Network Successful. NetworkId : %s "
|
|
% str(networkcmdresponse.id))
|
|
self.createPods(zone.pods, zoneId, networkcmdresponse.id)
|
|
'''Note: Swift needs cache storage first'''
|
|
self.createCacheStorages(zone.cacheStorages, zoneId)
|
|
self.createSecondaryStorages(zone.secondaryStorages, zoneId)
|
|
#add zone wide primary storages if any
|
|
if zone.primaryStorages:
|
|
self.createPrimaryStorages(zone.primaryStorages,
|
|
zoneId,
|
|
)
|
|
enabled = getattr(zone, 'enabled', 'True')
|
|
if enabled == 'True' or enabled is None:
|
|
self.enableZone(zoneId, "Enabled")
|
|
details = getattr(zone, 'details')
|
|
if details is not None:
|
|
det = [d.__dict__ for d in details]
|
|
self.updateZoneDetails(zoneId, det)
|
|
return
|
|
except Exception as e:
|
|
print("\nException Occurred %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("==== Create Zones Failed ===")
|
|
|
|
def isEipElbZone(self, zone):
|
|
if (zone.networktype == "Basic"
|
|
and len([x for x in zone.physical_networks[0].traffictypes if x.typ == 'Public']) > 0):
|
|
return True
|
|
return False
|
|
|
|
def setClient(self):
|
|
'''
|
|
@Name : setClient
|
|
@Desc : Sets the API Client retrieved from test client
|
|
'''
|
|
self.__apiClient = self.__testClient.getApiClient()
|
|
|
|
def updateConfiguration(self, globalCfg):
|
|
try:
|
|
if globalCfg is None or self.__apiClient is None:
|
|
return None
|
|
for config in globalCfg:
|
|
updateCfg = updateConfiguration.updateConfigurationCmd()
|
|
updateCfg.name = config.name
|
|
updateCfg.value = config.value
|
|
ret = self.__apiClient.updateConfiguration(updateCfg)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug(
|
|
"==UpdateConfiguration Successfull===")
|
|
except Exception as e:
|
|
print("Exception Occurred %s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.\
|
|
exception("===UpdateConfiguration Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def copyAttributesToCommand(self, source, command):
|
|
list(map(lambda attr: setattr(command, attr, getattr(source, attr, None)),
|
|
[attr for attr in dir(command) if not attr.startswith("__") and attr not in
|
|
["required", "isAsync"]]))
|
|
|
|
def configureS3(self, s3):
|
|
try:
|
|
if s3 is None:
|
|
return
|
|
command = addS3.addS3Cmd()
|
|
self.copyAttributesToCommand(s3, command)
|
|
ret = self.__apiClient.addS3(command)
|
|
if ret.id:
|
|
self.__tcRunLogger.debug("===AddS3 Successfull===")
|
|
self.__addToCleanUp("s3", ret.id)
|
|
except Exception as e:
|
|
self.__tcRunLogger.exception("====AddS3 Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def deploy(self):
|
|
try:
|
|
print("\n==== Deploy DC Started ====")
|
|
self.__tcRunLogger.debug("\n==== Deploy DC Started ====")
|
|
'''
|
|
Step1 : Set the Client
|
|
'''
|
|
self.setClient()
|
|
'''
|
|
Step2: Update the Configuration
|
|
'''
|
|
self.updateConfiguration(self.__config.globalConfig)
|
|
'''
|
|
Step3 :Deploy the Zone
|
|
'''
|
|
self.createZones(self.__config.zones)
|
|
self.configureS3(self.__config.s3)
|
|
'''
|
|
Persist the Configuration to an external file post DC creation
|
|
'''
|
|
self.__persistDcConfig()
|
|
print("\n====Deploy DC Successful=====")
|
|
self.__tcRunLogger.debug("\n====Deploy DC Successful====")
|
|
'''
|
|
Upload baremetalSwitch configuration(.rct) file if enabled zone has baremetal isolated network.
|
|
'''
|
|
self.addBaremetalRct(self.__config)
|
|
self.__tcRunLogger.debug("\n==== AddbaremetalRct Successful====")
|
|
|
|
return SUCCESS
|
|
except Exception as e:
|
|
print("\nException Occurred Under deploy :%s" % \
|
|
GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.debug("\n====Deploy DC Failed====")
|
|
print("\n====Deploy DC Failed====")
|
|
self.__cleanAndExit()
|
|
return FAILED
|
|
|
|
def configureTungstenService(self, zoneId, physicalNetworkId, tungstenprovider):
|
|
try:
|
|
createTFProviderCmd = createTungstenFabricProvider.createTungstenFabricProviderCmd()
|
|
createTFProviderCmd.zoneid = zoneId
|
|
createTFProviderCmd.name = tungstenprovider.name
|
|
createTFProviderCmd.tungstenproviderhostname = tungstenprovider.hostname
|
|
createTFProviderCmd.tungstengateway = tungstenprovider.gateway
|
|
self.__apiClient.createTungstenFabricProvider(createTFProviderCmd)
|
|
configTFServiceCmd = configTungstenFabricService.configTungstenFabricServiceCmd()
|
|
configTFServiceCmd.zoneid = zoneId
|
|
configTFServiceCmd.physicalnetworkid = physicalNetworkId
|
|
self.__apiClient.configTungstenFabricService(configTFServiceCmd)
|
|
except Exception as e:
|
|
print("\nException Occurred when config tungsten fabric service :%s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("====Config Tungsten Fabric Service Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def enableTungstenProvider(self, zoneId, physicalNetworkId):
|
|
provider = listNetworkServiceProviders.listNetworkServiceProvidersCmd()
|
|
provider.name = "Tungsten"
|
|
provider.physicalnetworkid = physicalNetworkId
|
|
provider.state = "Disabled"
|
|
providerres = self.__apiClient.listNetworkServiceProviders(provider)
|
|
if providerres and len(providerres) == 1:
|
|
self.enableProvider(providerres[0].id)
|
|
|
|
def createTungstenManagementNetwork(self, podId):
|
|
try:
|
|
createTFManagementNetworkCmd = createTungstenFabricManagementNetwork.createTungstenFabricManagementNetworkCmd()
|
|
createTFManagementNetworkCmd.podid = podId
|
|
self.__apiClient.createTungstenFabricManagementNetwork(createTFManagementNetworkCmd)
|
|
except Exception as e:
|
|
print("\nException Occurred when create tungsten fabric management network :%s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("====Create Tungsten Fabric Management Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
def createTungstenPublicNetwork(self, zoneId):
|
|
try:
|
|
createTFPublicNetworkCmd = createTungstenFabricPublicNetwork.createTungstenFabricPublicNetworkCmd()
|
|
createTFPublicNetworkCmd.zoneid = zoneId
|
|
self.__apiClient.createTungstenFabricPublicNetwork(createTFPublicNetworkCmd)
|
|
except Exception as e:
|
|
print("\nException Occurred when create tungsten fabric public network :%s" % GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception("====Create Tungsten Fabric Public Failed===")
|
|
self.__cleanAndExit()
|
|
|
|
class DeleteDataCenters:
|
|
|
|
'''
|
|
@Desc : Deletes the Data Center using the settings provided.
|
|
tc_client :Client for deleting the DC.
|
|
dc_cfg_file : obj file exported by DeployDataCenter
|
|
when successfully created DC.
|
|
This file is serialized one containing
|
|
entries with successful DC.
|
|
dc_cfg: If dc_cfg_file, is not available, we can use
|
|
the dictionary of elements to delete.
|
|
tc_run_logger: Logger to dump log messages.
|
|
'''
|
|
|
|
def __init__(self,
|
|
tc_client,
|
|
dc_cfg_file=None,
|
|
dc_cfg=None,
|
|
tc_run_logger=None
|
|
):
|
|
self.__dcCfgFile = dc_cfg_file
|
|
self.__dcCfg = dc_cfg
|
|
self.__tcRunLogger = tc_run_logger
|
|
self.__apiClient = None
|
|
self.__testClient = tc_client
|
|
|
|
def __deleteCmds(self, cmd_name, cmd_obj):
|
|
'''
|
|
@Name : __deleteCmds
|
|
@Desc : Deletes the entities provided by cmd
|
|
'''
|
|
if cmd_name.lower() == "deletehostcmd":
|
|
cmd_obj.forcedestroylocalstorage = "true"
|
|
cmd_obj.force = "true"
|
|
'''
|
|
Step1 : Prepare Host For Maintenance
|
|
'''
|
|
host_maint_cmd = prepareHostForMaintenance.\
|
|
prepareHostForMaintenanceCmd()
|
|
host_maint_cmd.id = cmd_obj.id
|
|
host_maint_resp = self.__apiClient.prepareHostForMaintenance(
|
|
host_maint_cmd)
|
|
if host_maint_resp:
|
|
'''
|
|
Step2 : List Hosts for Resource State
|
|
'''
|
|
list_host_cmd = listHosts.listHostsCmd()
|
|
list_host_cmd.id = cmd_obj.id
|
|
retries = 3
|
|
for i in range(retries):
|
|
list_host_resp = self.__apiClient.\
|
|
listHosts(list_host_cmd)
|
|
if (list_host_resp) and\
|
|
(list_host_resp[0].resourcestate == 'Maintenance'):
|
|
break
|
|
sleep(30)
|
|
if cmd_name.lower() == "deletestoragepoolcmd":
|
|
cmd_obj.forced = "true"
|
|
store_maint_cmd = enableStorageMaintenance.\
|
|
enableStorageMaintenanceCmd()
|
|
store_maint_cmd.id = cmd_obj.id
|
|
store_maint_resp = self.__apiClient.\
|
|
enableStorageMaintenance(store_maint_cmd)
|
|
if store_maint_resp:
|
|
list_store_cmd = listStoragePools.listStoragePoolsCmd()
|
|
list_store_cmd.id = cmd_obj.id
|
|
retries = 3
|
|
for i in range(retries):
|
|
store_maint_resp = self.__apiClient.\
|
|
listStoragePools(list_store_cmd)
|
|
if (store_maint_resp) and \
|
|
(store_maint_resp[0].state == 'Maintenance'):
|
|
break
|
|
sleep(30)
|
|
return cmd_obj
|
|
|
|
def __setClient(self):
|
|
'''
|
|
@Name : setClient
|
|
@Desc : Sets the API Client retrieved from test client
|
|
'''
|
|
self.__apiClient = self.__testClient.getApiClient()
|
|
|
|
def __cleanEntries(self):
|
|
'''
|
|
@Name : __cleanAndEntries
|
|
@Description: Cleans up the created DC in order of creation
|
|
'''
|
|
try:
|
|
ret = FAILED
|
|
if "order" in list(self.__dcCfg.keys()) and len(self.__dcCfg["order"]):
|
|
self.__dcCfg["order"].reverse()
|
|
print("\n====Clean Up Entries===", self.__dcCfg)
|
|
for type in self.__dcCfg["order"]:
|
|
self.__tcRunLogger.debug(
|
|
"====CleanUp Started For Type: %s====" %
|
|
type)
|
|
if type:
|
|
temp_ids = self.__dcCfg[type]
|
|
ids = [items for items in temp_ids if items]
|
|
for id in ids:
|
|
del_mod = "delete" + type
|
|
del_cmd = getattr(
|
|
globals()[del_mod],
|
|
del_mod + "Cmd")
|
|
del_cmd_obj = del_cmd()
|
|
del_cmd_resp = getattr(
|
|
globals()[del_mod],
|
|
del_mod + "Response")
|
|
del_cmd_obj.id = id
|
|
del_cmd_obj = self.__deleteCmds(
|
|
del_mod +
|
|
"Cmd",
|
|
del_cmd_obj)
|
|
del_func = getattr(self.__apiClient, del_mod)
|
|
del_cmd_resp = del_func(del_cmd_obj)
|
|
if del_cmd_resp:
|
|
self.__tcRunLogger.debug(
|
|
"====%s CleanUp Failed. ID: %s ===" %
|
|
(type, id))
|
|
else:
|
|
self.__tcRunLogger.debug(
|
|
"====%s CleanUp Successful. ID : %s===" %
|
|
(type, id))
|
|
ret = SUCCESS
|
|
except Exception as e:
|
|
print("\n==== Exception Under __cleanEntries: %s ==== % " \
|
|
% GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception(
|
|
"\n==== Exception Under __cleanEntries: %s ==== % " %
|
|
GetDetailExceptionInfo(e))
|
|
finally:
|
|
return ret
|
|
|
|
def removeDataCenter(self):
|
|
'''
|
|
@Name : removeDataCenter
|
|
@Desc : Removes the Data Center provided by Configuration
|
|
If Input dc file configuration is None, uses the cfg provided
|
|
else uses the dc file to get the configuration
|
|
'''
|
|
try:
|
|
self.__setClient()
|
|
self.__tcRunLogger.debug("====DeployDC: CleanUp Started====")
|
|
print("\n====DeployDC: CleanUp Started====")
|
|
ret = FAILED
|
|
if self.__dcCfgFile:
|
|
file_to_read = open(self.__dcCfgFile, 'rb')
|
|
if file_to_read:
|
|
self.__dcCfg = pickle.load(file_to_read)
|
|
if self.__dcCfg:
|
|
ret = self.__cleanEntries()
|
|
except Exception as e:
|
|
print("\n==== Exception Under removeDataCenter: %s ====" % \
|
|
GetDetailExceptionInfo(e))
|
|
self.__tcRunLogger.exception(
|
|
"===DeployDC CleanUp FAILED: %s ====" %
|
|
GetDetailExceptionInfo(e))
|
|
finally:
|
|
return ret
|
|
|
|
def mkdirpath(path):
|
|
try:
|
|
os.makedirs(path)
|
|
except OSError as exc:
|
|
if exc.errno == errno.EEXIST and os.path.isdir(path):
|
|
pass
|
|
else:
|
|
raise
|
|
|
|
if __name__ == "__main__":
|
|
'''
|
|
@Desc : This module facilitates the following:
|
|
1. Deploying DataCenter by using the input provided
|
|
configuration.
|
|
EX: python deployDataCenter.py -i <inp-cfg-file> [-l <directory with logs and output data location>]
|
|
2. Removes a created DataCenter by providing
|
|
the input configuration file and data center settings file
|
|
EX: python deployDataCenter.py -i <inp-cfg-file>
|
|
-r <dc_exported_entries> [-l <directory with logs and output data location>]
|
|
'''
|
|
parser = OptionParser()
|
|
parser.add_option("-i", "--input", action="store", default=None, dest="input",
|
|
help="The path where the json zones config file is located.")
|
|
|
|
parser.add_option("-r", "--remove", action="store", default=None, dest="remove",
|
|
help="The path to file where the created dc entries are kept.")
|
|
|
|
parser.add_option("-l", "--logdir", action="store", default=None, dest="logdir",
|
|
help="The directory where result logs of running the script are stored:"
|
|
"[dc_entries.obj, failed_plus_exceptions.txt, runinfo.txt]." +
|
|
"Created automatically if doesn't exists.")
|
|
|
|
(options, args) = parser.parse_args()
|
|
|
|
'''
|
|
Verify the input validity
|
|
'''
|
|
if options.input is None and options.remove is None:
|
|
print("\n==== For DeployDataCenter: Please Specify a valid Input Configuration File====")
|
|
print("\n==== For DeleteDataCenters: Please Specify a valid Input Configuration File and DC Settings====")
|
|
exit(1)
|
|
|
|
'''
|
|
Imports the Modules Required
|
|
'''
|
|
from marvin.marvinLog import MarvinLog
|
|
from marvin.cloudstackTestClient import CSTestClient
|
|
|
|
'''
|
|
Step1: Create the Logger
|
|
'''
|
|
if (options.input) and not (os.path.isfile(options.input)):
|
|
print("\n=== Invalid Input Config File Path, Please Check ===")
|
|
exit(1)
|
|
|
|
log_obj = MarvinLog("CSLog")
|
|
cfg = configGenerator.getSetupConfig(options.input)
|
|
log = cfg.logger
|
|
|
|
if options.logdir != None:
|
|
mkdirpath(options.logdir)
|
|
|
|
ret = log_obj.createLogs("DeployDataCenter", log, options.logdir, options.logdir == None)
|
|
if ret != FAILED:
|
|
log_folder_path = log_obj.getLogFolderPath()
|
|
tc_run_logger = log_obj.getLogger()
|
|
else:
|
|
print("\n===Log Creation Failed. Please Check===")
|
|
exit(1)
|
|
|
|
'''
|
|
Step2 : Create Test Client
|
|
'''
|
|
obj_tc_client = CSTestClient(cfg.mgtSvr[0], cfg.dbSvr,
|
|
logger=tc_run_logger)
|
|
if obj_tc_client and obj_tc_client.createTestClient() == FAILED:
|
|
print("\n=== TestClient Creation Failed===")
|
|
exit(1)
|
|
|
|
'''
|
|
Step3: Verify and continue whether to deploy a DC or remove a DC
|
|
'''
|
|
|
|
if (options.input) and (os.path.isfile(options.input)) and \
|
|
(options.remove is None):
|
|
'''
|
|
@Desc : Deploys a Data Center with provided Config
|
|
'''
|
|
deploy = DeployDataCenters(obj_tc_client,
|
|
cfg,
|
|
tc_run_logger,
|
|
log_folder_path=log_folder_path)
|
|
if deploy.deploy() == FAILED:
|
|
print("\n===Deploy Failed===")
|
|
tc_run_logger.debug("\n===Deploy Failed===");
|
|
exit(1)
|
|
|
|
|
|
if options.remove and os.path.isfile(options.remove) and options.input:
|
|
'''
|
|
@Desc : Removes a Data Center with provided Config
|
|
'''
|
|
remove_dc_obj = DeleteDataCenters(obj_tc_client,
|
|
dc_cfg_file=options.remove,
|
|
tc_run_logger=tc_run_logger
|
|
)
|
|
if remove_dc_obj:
|
|
if remove_dc_obj.removeDataCenter() == FAILED:
|
|
print("\n===Removing DataCenter Failed===")
|
|
tc_run_logger.debug("\n===Removing DataCenter Failed===")
|
|
exit(1)
|
|
else:
|
|
print("\n===Removing DataCenter Successful===")
|
|
tc_run_logger.debug("\n===Removing DataCenter Successful===")
|
|
|
|
# All OK exit with 0 exitcode
|
|
exit(0)
|