etan39
/
cloudstack
mirror of https://github.com/apache/cloudstack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

support for traffic type and external devices configuration 

* traffictypes = 'Guest', 'Management', 'Public', 'Storage'
    - corresponding nic labels are given in the labeldict
* External device providers JuniperSrx, NetScaler and F5 load balancing
can now be configured

* examples are shown in the configGenerator.py script for basic,
advanced and EIP/ELB based zones
This commit is contained in:
Prasanna Santhanam 2012-08-09 14:12:45 +05:30
parent 4f774d227b
commit 81208a5135
2 changed files with 357 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

282
tools/marvin/marvin/configGenerator.py
View File

@ -63,21 +63,22 @@ class zone():
self.vlan = None
'''default public network, in advanced mode'''
self.ipranges = []
self.networks = []
self.physical_networks = []
self.pods = []
self.secondaryStorages = []
'''enable default virtual router provider'''
vrouter = provider()
vrouter.name = 'VirtualRouter'
self.providers = [vrouter]
class provider():
def __init__(self):
self.name = None
self.state = None
self.broadcastdomainrange = 'ZONE'
self.zoneid = None
self.servicelist = []
class traffictype():
def __init__(self, typ, labeldict=None):
self.typ = typ #Guest/Management/Public
if labeldict:
self.xen = labeldict['xen'] if 'xen' in labeldict.keys() else None
self.kvm = labeldict['kvm'] if 'kvm' in labeldict.keys() else None
self.vmware = labeldict['vmware'] if 'vmware' in labeldict.keys() else None
#{
# 'xen' : 'cloud-xen',
# 'kvm' : 'cloud-kvm',
# 'vmware' : 'cloud-vmware'
#}
class pod():
def __init__(self):
@ -119,7 +120,28 @@ class host():
self.hostmac = None
self.hosttags = None
self.memory = None
class physical_network():
def __init__(self):
self.name = None
self.tags = []
self.traffictypes = []
self.broadcastdomainrange = 'Zone'
self.vlan = None
'''enable default virtual router provider'''
vrouter = provider()
vrouter.name = 'VirtualRouter'
self.providers = [vrouter]
class provider():
def __init__(self, name=None):
self.name = name
self.state = None
self.broadcastdomainrange = 'ZONE'
self.zoneid = None
self.servicelist = []
self.devices = []
class network():
def __init__(self):
self.displaytext = None
@ -151,6 +173,77 @@ class primaryStorage():
class secondaryStorage():
def __init__(self):
self.url = None
class netscaler():
def __init__(self, hostname=None, username='nsroot', password='nsroot'):
self.hostname = hostname
self.username = username
self.password = password
self.networkdevicetype = 'NetscalerVPXLoadBalancer'
self.publicinterface = '1/1'
self.privateinterface = '1/1'
self.numretries = '2'
self.lbdevicecapacity = '50'
self.lbdevicededicated = 'false'
def getUrl(self):
return repr(self)
def __repr__(self):
req = zip(self.__dict__.keys(), self.__dict__.values())
return self.hostname+"?" + "&".join(["=".join([r[0], r[1]]) \
for r in req])
class srx():
def __init__(self, hostname=None, username='root', password='admin'):
self.hostname = hostname
self.username = username
self.password = password
self.networkdevicetype = 'JuniperSRXFirewall'
self.publicinterface = '1/1'
self.privateinterface = '1/1'
self.numretries = '2'
self.fwdevicededicated = 'false'
self.timeout = '300'
self.publicnetwork = 'untrusted'
self.privatenetwork = 'trusted'
def getUrl(self):
return repr(self)
def __repr__(self):
req = zip(self.__dict__.keys(), self.__dict__.values())
return self.hostname+"?" + "&".join(["=".join([r[0], r[1]]) \
for r in req])
class bigip():
def __init__(self, hostname=None, username='root', password='default'):
self.hostname = hostname
self.username = username
self.password = password
self.networkdevicetype = 'F5BigIpLoadBalancer'
self.publicinterface = '1/1'
self.privateinterface = '1/1'
self.numretries = '2'
self.lbdevicededicated = 'false'
self.lbdevicecapacity = '50'
def getUrl(self):
return repr(self)
def __repr__(self):
req = zip(self.__dict__.keys(), self.__dict__.values())
return self.hostname+"?" + "&".join(["=".join([r[0], r[1]]) \
for r in req])
def getDeviceUrl(obj):
req = zip(obj.__dict__.keys(), obj.__dict__.values())
if obj.hostname:
return "http://" + obj.hostname+"?" + "&".join(["=".join([r[0], r[1]]) \
for r in req])
else:
return None
'''sample code to generate setup configuration file'''
def describe_setup_in_basic_mode():
@ -164,7 +257,19 @@ def describe_setup_in_basic_mode():
z.internaldns2 = "192.168.110.253"
z.name = "test"+str(l)
z.networktype = 'Basic'
#If security groups are reqd
sgprovider = provider()
sgprovider.broadcastdomainrange = 'Pod'
sgprovider.name = 'SecurityGroupProvider'
pn = physical_network()
pn.name = "test-network"
pn.traffictypes = [traffictype("Guest"), traffictype("Management")]
pn.providers.append(sgprovider)
z.physical_networks.append(pn)
'''create 10 pods'''
for i in range(2):
p = pod()
@ -196,8 +301,6 @@ def describe_setup_in_basic_mode():
h = host()
h.username = "root"
h.password = "password"
memory = 8*1024*1024*1024
localstorage=1*1024*1024*1024*1024
#h.url = "http://Sim/%d%d%d%d/cpucore=1&cpuspeed=8000&memory=%d&localstorage=%d"%(l,i,j,k,memory,localstorage)
h.url = "http://Sim/%d%d%d%d"%(l,i,j,k)
c.hosts.append(h)
@ -205,7 +308,6 @@ def describe_setup_in_basic_mode():
'''add 2 primary storages'''
for m in range(2):
primary = primaryStorage()
size=1*1024*1024*1024*1024
primary.name = "primary"+str(l) + str(i) + str(j) + str(m)
#primary.url = "nfs://localhost/path%s/size=%d"%(str(l) + str(i) + str(j) + str(m), size)
primary.url = "nfs://localhost/path%s"%(str(l) + str(i) + str(j) + str(m))
@ -259,6 +361,129 @@ def describe_setup_in_basic_mode():
return zs
def describe_setup_in_eip_mode():
"""
Setting up an EIP/ELB enabled zone with netscaler provider
"""
zs = cloudstackConfiguration()
for l in range(1):
z = zone()
z.dns1 = "8.8.8.8"
z.dns2 = "4.4.4.4"
z.internaldns1 = "192.168.110.254"
z.internaldns2 = "192.168.110.253"
z.name = "test"+str(l)
z.networktype = 'Basic'
#If security groups are reqd
sgprovider = provider()
sgprovider.broadcastdomainrange = 'Pod'
sgprovider.name = 'SecurityGroupProvider'
nsprovider = provider()
nsprovider.name = 'Netscaler'
ns = netscaler()
ns.hostname = '10.147.40.100'
nsprovider.devices.append(ns)
pn = physical_network()
pn.name = "test-network"
pn.traffictypes = [traffictype("Guest", {"xen": "cloud-guest"}), traffictype("Management"), traffictype("Public", { "xen": "cloud-public"})]
pn.providers.extend([sgprovider, nsprovider])
z.physical_networks.append(pn)
'''create 10 pods'''
for i in range(2):
p = pod()
p.name = "test" +str(l) + str(i)
p.gateway = "192.168.%d.1"%i
p.netmask = "255.255.255.0"
p.startip = "192.168.%d.150"%i
p.endip = "192.168.%d.220"%i
'''add two pod guest ip ranges'''
for j in range(2):
ip = iprange()
ip.gateway = p.gateway
ip.netmask = p.netmask
ip.startip = "192.168.%d.%d"%(i,j*20)
ip.endip = "192.168.%d.%d"%(i,j*20+10)
p.guestIpRanges.append(ip)
'''add 10 clusters'''
for j in range(2):
c = cluster()
c.clustername = "test"+str(l)+str(i) + str(j)
c.clustertype = "CloudManaged"
c.hypervisor = "Simulator"
'''add 10 hosts'''
for k in range(2):
h = host()
h.username = "root"
h.password = "password"
#h.url = "http://Sim/%d%d%d%d/cpucore=1&cpuspeed=8000&memory=%d&localstorage=%d"%(l,i,j,k,memory,localstorage)
h.url = "http://Sim/%d%d%d%d"%(l,i,j,k)
c.hosts.append(h)
'''add 2 primary storages'''
for m in range(2):
primary = primaryStorage()
primary.name = "primary"+str(l) + str(i) + str(j) + str(m)
#primary.url = "nfs://localhost/path%s/size=%d"%(str(l) + str(i) + str(j) + str(m), size)
primary.url = "nfs://localhost/path%s"%(str(l) + str(i) + str(j) + str(m))
c.primaryStorages.append(primary)
p.clusters.append(c)
z.pods.append(p)
'''add two secondary'''
for i in range(5):
secondary = secondaryStorage()
secondary.url = "nfs://localhost/path"+str(l) + str(i)
z.secondaryStorages.append(secondary)
zs.zones.append(z)
'''Add one mgt server'''
mgt = managementServer()
mgt.mgtSvrIp = "localhost"
zs.mgtSvr.append(mgt)
'''Add a database'''
db = dbServer()
db.dbSvr = "localhost"
zs.dbSvr = db
'''add global configuration'''
global_settings = {'expunge.delay': '60',
'expunge.interval': '60',
'expunge.workers': '3',
}
for k,v in global_settings.iteritems():
cfg = configuration()
cfg.name = k
cfg.value = v
zs.globalConfig.append(cfg)
''''add loggers'''
testClientLogger = logger()
testClientLogger.name = "TestClient"
testClientLogger.file = "/tmp/testclient.log"
testCaseLogger = logger()
testCaseLogger.name = "TestCase"
testCaseLogger.file = "/tmp/testcase.log"
zs.logger.append(testClientLogger)
zs.logger.append(testCaseLogger)
return zs
'''sample code to generate setup configuration file'''
def describe_setup_in_advanced_mode():
zs = cloudstackConfiguration()
@ -273,6 +498,24 @@ def describe_setup_in_advanced_mode():
z.networktype = 'Advanced'
z.guestcidraddress = "10.1.1.0/24"
z.vlan = "100-2000"
pn = physical_network()
pn.name = "test-network"
pn.traffictypes = [traffictype("Guest"), traffictype("Management"), traffictype("Public")]
vpcprovider = provider('VpcVirtualRouter')
nsprovider = provider('Netscaler')
nsprovider.devices.append(netscaler(hostname='10.147.40.100'))
srxprovider = provider('JuniperSRX')
srxprovider.devices.append(srx(hostname='10.147.40.3'))
f5provider = provider('F5BigIp')
f5provider.devices.append(bigip(hostname='10.147.40.3'))
pn.providers.extend([vpcprovider, nsprovider, srxprovider, f5provider])
z.physical_networks.append(pn)
'''create 10 pods'''
for i in range(2):
@ -295,8 +538,6 @@ def describe_setup_in_advanced_mode():
h = host()
h.username = "root"
h.password = "password"
memory = 8*1024*1024*1024
localstorage=1*1024*1024*1024*1024
#h.url = "http://Sim/%d%d%d%d/cpucore=1&cpuspeed=8000&memory=%d&localstorage=%d"%(l,i,j,k,memory,localstorage)
h.url = "http://Sim/%d%d%d%d"%(l,i,j,k)
c.hosts.append(h)
@ -304,7 +545,6 @@ def describe_setup_in_advanced_mode():
'''add 2 primary storages'''
for m in range(2):
primary = primaryStorage()
size=1*1024*1024*1024*1024
primary.name = "primary"+str(l) + str(i) + str(j) + str(m)
#primary.url = "nfs://localhost/path%s/size=%d"%(str(l) + str(i) + str(j) + str(m), size)
primary.url = "nfs://localhost/path%s"%(str(l) + str(i) + str(j) + str(m))
@ -394,3 +634,5 @@ if __name__ == "__main__":
(options, args) = parser.parse_args()
config = describe_setup_in_basic_mode()
generate_setup_config(config, options.output)

175
tools/marvin/marvin/deployDataCenter.py
View File

@ -83,7 +83,7 @@ class deployDataCenters():
primarycmd.clusterid = clusterId
self.apiClient.createStoragePool(primarycmd)
def createpods(self, pods, zone, zoneId, networkId=None):
def createpods(self, pods, zoneId, networkId=None):
if pods is None:
return
for pod in pods:
@ -135,7 +135,7 @@ class deployDataCenters():
secondarycmd.zoneid = zoneId
self.apiClient.addSecondaryStorage(secondarycmd)
def createnetworks(self, networks, zoneId, mode):
def createnetworks(self, networks, zoneId):
if networks is None:
return
for network in networks:
@ -157,13 +157,13 @@ class deployDataCenters():
networkId = networkcmdresponse.id
return networkId
def createPhysicalNetwork(self, name, zoneid, vlan=None):
def createPhysicalNetwork(self, net, zoneid):
phynet = createPhysicalNetwork.createPhysicalNetworkCmd()
phynet.zoneid = zoneid
phynet.name = name
if vlan:
phynet.vlan = vlan
return self.apiClient.createPhysicalNetwork(phynet)
phynet.name = net.name
phynetwrk = self.apiClient.createPhysicalNetwork(phynet)
self.addTrafficTypes(phynetwrk.id, net.traffictypes)
return phynetwrk
def updatePhysicalNetwork(self, networkid, state="Enabled", vlan=None):
upnet = updatePhysicalNetwork.updatePhysicalNetworkCmd()
@ -172,75 +172,86 @@ class deployDataCenters():
if vlan:
upnet.vlan = vlan
return self.apiClient.updatePhysicalNetwork(upnet)
def configureProviders(self, phynetwrk, zone):
pnetprov = listNetworkServiceProviders.listNetworkServiceProvidersCmd()
pnetprov.physicalnetworkid = phynetwrk.id
pnetprov.state = "Disabled"
pnetprov.name = "VirtualRouter"
pnetprovres = self.apiClient.listNetworkServiceProviders(pnetprov)
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
vrconfigresponse = \
self.apiClient.configureVirtualRouterElement(vrconfig)
def enableProvider(self, provider_id):
upnetprov = \
updateNetworkServiceProvider.updateNetworkServiceProviderCmd()
upnetprov.id = vrprov.nspid
upnetprov.id = provider_id
upnetprov.state = "Enabled"
upnetprovresponse = \
self.apiClient.updateNetworkServiceProvider(upnetprov)
if zone.networktype == "Basic" and zone.securitygroupenabled:
sgprovider = configGenerator.provider()
sgprovider.name = "SecurityGroupProvider"
zone.providers.append(sgprovider)
if zone.networktype == "Advanced":
def configureProviders(self, phynetwrk, providers):
"""
We will enable the virtualrouter elements for all zones. Other providers
like NetScalers, SRX, etc are explicitly added/configured
"""
for provider in providers:
pnetprov = listNetworkServiceProviders.listNetworkServiceProvidersCmd()
pnetprov.physicalnetworkid = phynetwrk.id
pnetprov.state = "Disabled"
pnetprov.name = "VpcVirtualRouter"
pnetprov.name = provider.name
pnetprovres = self.apiClient.listNetworkServiceProviders(pnetprov)
if len(pnetprovres) > 0:
vpcvrprov = listVirtualRouterElements.listVirtualRouterElementsCmd()
vpcvrprov.nspid = pnetprovres[0].id
vpcvrprovresponse = self.apiClient.listVirtualRouterElements(vpcvrprov)
vpcvrprovid = vpcvrprovresponse[0].id
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
vpcvrconfig = \
configureVirtualRouterElement.configureVirtualRouterElementCmd()
vpcvrconfig.enabled = "true"
vpcvrconfig.id = vpcvrprovid
vpcvrconfigresponse = \
self.apiClient.configureVirtualRouterElement(vpcvrconfig)
upnetprov = \
updateNetworkServiceProvider.updateNetworkServiceProviderCmd()
upnetprov.id = vpcvrprov.nspid
upnetprov.state = "Enabled"
upnetprovresponse = \
self.apiClient.updateNetworkServiceProvider(upnetprov)
vrconfig = \
configureVirtualRouterElement.configureVirtualRouterElementCmd()
vrconfig.enabled = "true"
vrconfig.id = vrprovid
self.apiClient.configureVirtualRouterElement(vrconfig)
self.enableProvider(pnetprovres[0].id)
elif provider.name in ['Netscaler', 'JuniperSRX', 'F5BigIp']:
netprov = addNetworkServiceProvider.addNetworkServiceProviderCmd()
netprov.name = provider.name
netprov.physicalnetworkid = phynetwrk.id
result = self.apiClient.addNetworkServiceProvider(netprov)
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
self.apiClient.addNetscalerLoadBalancer(dev)
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
self.apiClient.addSrxFirewall(dev)
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
self.apiClient.addF5LoadBalancer(dev)
else:
print "Device %s doesn't match any know provider type"%device
self.enableProvider(result.id)
def addTrafficTypes(self, physical_network_id, traffictypes):
[self.addTrafficType(physical_network_id, traffic_type) for traffic_type in traffictypes]
def addTrafficTypes(self, physical_network_id, traffictypes=None, \
network_labels=None):
[self.addTrafficType(physical_network_id, traffictype) for \
traffictype in traffictypes]
def addTrafficType(self, physical_network_id, traffictype, \
network_label=None):
def addTrafficType(self, physical_network_id, traffictype):
traffic_type = addTrafficType.addTrafficTypeCmd()
traffic_type.physicalnetworkid = physical_network_id
traffic_type.traffictype = traffictype
traffic_type.traffictype = traffictype.typ
if traffictype.labeldict:
traffic_type.kvmnetworklabel = traffictype.labeldict.xen
traffic_type.xennetworklabel = traffictype.labeldict.kvm
traffic_type.vmwarenetworklabel = traffictype.labeldict.vmware
return self.apiClient.addTrafficType(traffic_type)
def enableZone(self, zoneid, allocation_state="Enabled"):
@ -260,24 +271,21 @@ class deployDataCenters():
createzone.securitygroupenabled = zone.securitygroupenabled
createzone.networktype = zone.networktype
createzone.guestcidraddress = zone.guestcidraddress
zoneresponse = self.apiClient.createZone(createzone)
zoneId = zoneresponse.id
phynetwrk = self.createPhysicalNetwork(zone.name + "-pnet", \
zoneId)
self.configureProviders(phynetwrk, zone)
self.updatePhysicalNetwork(phynetwrk.id, "Enabled", vlan=zone.vlan)
for pnet in zone.physical_networks:
phynetwrk = self.createPhysicalNetwork(pnet, zoneId)
self.configureProviders(phynetwrk, pnet.providers)
self.updatePhysicalNetwork(phynetwrk.id, "Enabled", vlan=zone.vlan)
if zone.networktype == "Basic":
self.addTrafficTypes(phynetwrk.id, ["Guest", "Management"])
listnetworkoffering = listNetworkOfferings.listNetworkOfferingsCmd()
listnetworkoffering = \
listNetworkOfferings.listNetworkOfferingsCmd()
listnetworkoffering.name = \
"DefaultSharedNetworkOfferingWithSGService"
listnetworkoffering.name = "DefaultSharedNetscalerEIPandELBNetworkOffering" \
if len(filter(lambda x : x.typ == 'Public', zone.physical_networks.traffictypes)) > 0 \
else "DefaultSharedNetworkOfferingWithSGService"
listnetworkofferingresponse = \
self.apiClient.listNetworkOfferings(listnetworkoffering)
@ -288,19 +296,26 @@ class deployDataCenters():
guestntwrk.zoneid = zoneId
guestntwrk.networkofferingid = \
listnetworkofferingresponse[0].id
networkid = self.createnetworks([guestntwrk], zoneId, zone.networktype)
self.createpods(zone.pods, zone, zoneId, networkid)
networkid = self.createnetworks([guestntwrk], zoneId)
self.createpods(zone.pods, zoneId, networkid)
if self.isEipElbZone(zone):
self.createVlanIpRanges(zone.networktype, zone.ipranges, \
zoneId)
if zone.networktype == "Advanced":
self.createpods(zone.pods, zone, zoneId)
self.addTrafficTypes(phynetwrk.id, ["Guest", "Public", \
"Management"])
self.createpods(zone.pods, zoneId)
self.createVlanIpRanges(zone.networktype, zone.ipranges, \
zoneId)
self.createSecondaryStorages(zone.secondaryStorages, zoneId)
self.enableZone(zoneId, "Enabled")
return
def isEipElbZone(self, zone):
if zone.networktype == "Basic" and len(filter(lambda x : x.typ == 'Public', zone.physical_networks.traffictypes)) > 0:
return True
return False
def registerApiKey(self):
listuser = listUsers.listUsersCmd()