class RedVPCRouter():
templateName = "tiny Linux"
hypervisor = "XenServer"
serviceOffering = "tinyOffering"
def __init__(self, l, options):
self.options = options
self.log = l
utils = CSUtils()
conn = utils.getConnection()
self.apiclient = CloudStackAPIClient(conn)
self.get_zone()
self.vms = []
self.networks = []
self.vpcs = []
self.isolated = []
def add_comm(self, comm):
self.comm = comm
def get_zone(self):
self.log.ptest("Getting Zone info")
cmd = listZones.listZonesCmd()
ret = self.apiclient.listZones(cmd)
if ret is None:
self.log.extra("No zones")
self.log.failure()
for zone in ret:
self.zone = zone
self.log.success()
def list_routers(self, rid='', is_vpc=IS_VPC):
self.log.ptest("Finding routers")
cmd = listRouters.listRoutersCmd()
ret = self.apiclient.listRouters(cmd)
rtrs = []
if ret is None:
self.log.extra("No routers found it has gone really wrong")
self.log.failure()
for router in ret:
if is_vpc:
if router.vpcid == rid:
rtrs.append(router)
else:
if router.networkdomain == rid:
rtrs.append(router)
self.log.success()
return rtrs
def set_vpc_offerings(self, name):
self.log.ptest("Getting VPC service offering")
cmd = listVPCOfferings.listVPCOfferingsCmd()
ret = self.apiclient.listVPCOfferings(cmd)
self.vpc_off = None
for off in ret:
if off.displaytext == name:
self.vpc_off = off
if self.vpc_off is None:
self.log.extra("No VPC offering found with name %s" % name)
self.log.failure()
self.log.success()
def list_network_offerings(self, name):
cmd = listNetworkOfferings.listNetworkOfferingsCmd()
ret = self.apiclient.listNetworkOfferings(cmd)
for off in ret:
if off.name == name:
return off
return None
def set_isolated_offerings(self, name):
self.log.ptest("Getting Isolated service offering")
cmd = listNetworkOfferings.listNetworkOfferingsCmd()
ret = self.apiclient.listNetworkOfferings(cmd)
self.isolated_off = None
for off in ret:
if off.name == name:
self.isolated_off = off
if self.isolated_off is None:
self.log.extra("No Isolated offering found with name %s" % name)
self.log.failure()
self.log.success()
def list_templates(self, name):
cmd = listTemplates.listTemplatesCmd()
cmd.templatefilter = "all"
cmd.name = name
cmd.listAll = True
cmd.zone = self.zone.id
return self.apiclient.listTemplates(cmd)
def list_instances(self):
cmd = listVirtualMachines.listVirtualMachinesCmd()
return self.apiclient.listVirtualMachines(cmd)
def instance_exists(self, name):
vms = self.list_instances()
if vms is None:
return False
for vm in vms:
if vm.name == name:
return vm.id
return False
def getServiceOffering(self, name):
cmd = listServiceOfferings.listServiceOfferingsCmd()
ret = self.apiclient.listServiceOfferings(cmd)
for t in ret:
if t.name.startswith(name):
return t.id
return False
def list_vpc(self):
cmd = listVPCs.listVPCsCmd()
ret = self.apiclient.listVPCs(cmd)
return ret
def vpc_exists(self, name):
vpcs = self.list_vpc()
if vpcs is None:
return False
for vpc in vpcs:
if vpc.name == name:
return vpc
return False
def get_network(self, name):
nets = self.list_networks()
if nets is None:
return None
for net in nets:
if net.name == name:
return net
return None
def list_networks(self):
cmd = listNetworks.listNetworksCmd()
ret = self.apiclient.listNetworks(cmd)
if ret is None:
return None
return ret
def list_ips(self, net):
self.ips = []
cmd = listPublicIpAddresses.listPublicIpAddressesCmd()
cmd.listAll = True
ret = self.apiclient.listPublicIpAddresses(cmd)
self.log.ptest("Getting public ips for network %s" % net)
for ip in ret:
if hasattr(ip, "associatednetworkname") and ip.associatednetworkname == net:
self.ips.append(ip)
if len(self.ips) > 0:
self.log.success()
else:
self.log.extra("No public IP")
self.log.failure()
def get_acl(self, traffictype, action):
cmd = listNetworkACLs.listNetworkACLsCmd()
ret = self.apiclient.listNetworkACLs(cmd)
if ret is None:
self.log.extra("No Network ACLS found")
self.log.failure()
for acl in ret:
if acl.traffictype == traffictype and acl.action == action:
return acl
def create_network(self, vpc, name, gateway, netmask):
self.log.ptest("Creating network %s (%s)" % (name, gateway))
vid = self.vpc_exists(vpc).id
netname = "%s-%s" % (vpc, name)
if not vid:
self.log.extra("No vpc called %s" % vpc)
self.log.failure(True)
n = self.get_network(netname)
if n is not None:
self.log.extra("Network %s already exists" % netname)
self.networks.append(n.id)
self.log.success()
return n
cmd = createNetwork.createNetworkCmd()
cmd.zoneid = self.zone.id
cmd.name = netname
cmd.displaytext = netname
cmd.gateway = gateway
cmd.netmask = netmask
cmd.vpcid = vid
cmd.aclid = self.get_acl("Egress", "Allow").aclid
cmd.networkofferingid = self.list_network_offerings("DefaultIsolatedNetworkOfferingForVpcNetworks").id
ret = self.apiclient.createNetwork(cmd)
self.networks.append(ret.id)
time.sleep(20)
self.log.success()
return ret
def create_isolated_network(self, name, gw, mask):
self.log.ptest("Creating Isolated Network %s (%s/%s)" % (name, gw, mask))
cmd = listNetworks.listNetworksCmd()
networks = self.apiclient.listNetworks(cmd)
if networks is not None:
for net in networks:
if net.name == name:
self.networks.append(net.id)
self.log.extra("Exists")
self.log.success()
return
cmd = createNetwork.createNetworkCmd()
cmd.zoneid = self.zone.id
cmd.name = name
cmd.displaytext = name
cmd.networkofferingid = self.isolated_off.id
cmd.gateway = gw
cmd.netmask = mask
cmd.networkdomain = "%s.local" % name
ret = self.apiclient.createNetwork(cmd)
self.networks.append(ret.id)
self.log.success()
return ret.id
def create_vpc(self, name, cidr):
self.log.ptest("Creating Redundant VPC %s (%s)" % (name, cidr))
vpc = self.vpc_exists(name)
if vpc:
self.log.extra("Already exists")
self.log.success()
self.vpcs.append(vpc.id)
return vpc.id
cmd = createVPC.createVPCCmd()
cmd.name = name
cmd.displaytext = name
cmd.vpcofferingid = self.vpc_off.id
cmd.zoneid = self.zone.id
cmd.cidr = cidr
# cmd.account = account
# cmd.domainid = domainid
# cmd.networkDomain = networkDomain
ret = self.apiclient.createVPC(cmd)
self.vpcs.append(ret.id)
self.log.success()
return ret.id
def list_acls(self, name):
cmd = listNetworkACLLists.listNetworkACLListsCmd()
ret = self.apiclient.listNetworkACLLists(cmd)
for acl in ret:
if acl.name == name:
return acl
return None
def create_acl_list(self, name, vid):
self.log.ptest("Creating acl list %s" % name)
acl = self.list_acls(name)
if acl is None:
cmd = createNetworkACLList.createNetworkACLListCmd()
cmd.vpcid = vid
cmd.name = name
cmd.description = name
acl = self.apiclient.createNetworkACLList(cmd)
self.log.success()
else:
self.log.extra("exists")
self.log.skipped()
return acl
def add_acl_rule(self, number, acl, port, direction):
self.log.ptest("Adding %s rule for port %s" % (direction, port))
cmd = listNetworkACLs.listNetworkACLsCmd()
cmd.aclid = acl.id
ret = self.apiclient.listNetworkACLs(cmd)
if ret is not None:
for rule in ret:
if rule.number == number:
self.log.extra("Exists")
self.log.skipped()
return
cmd = createNetworkACL.createNetworkACLCmd()
cmd.aclid = acl.id
cmd.startport = port
cmd.endport = port
cmd.cidrlist = ''
cmd.number = number
cmd.traffictype = direction
cmd.protocol = 'tcp'
self.apiclient.createNetworkACL(cmd)
self.log.success()
def replace_acl(self, acl, net):
self.log.ptest("Setting acl on %s to %s" % (net.name, acl.name))
cmd = replaceNetworkACLList.replaceNetworkACLListCmd()
cmd.networkid = net.id
cmd.aclid = acl.id
self.apiclient.replaceNetworkACLList(cmd)
self.log.success()
def create_instance(self, name, network):
self.log.ptest("Creating virtual machine %s in %s" % (name, network))
v = self.instance_exists(name)
if v:
self.vms.append(v)
self.log.extra("Already exists")
self.log.success()
return
cmd = deployVirtualMachine.deployVirtualMachineCmd()
cmd.name = name
cmd.displayname = name
cmd.zoneid = self.zone.id
so = self.getServiceOffering(self.serviceOffering)
if so is False:
self.log.extra("Cannot find service Offering %s]" % self.serviceOffering)
self.log.failure()
cmd.serviceofferingid = so
temp = self.list_templates(self.templateName)
if temp is None:
self.log.extra("Cannot find template %s" % self.templateName)
self.log.failure()
neto = self.get_network(network)
if neto is None:
self.log.extra("Cannot find network %s" % network)
self.log.failure()
cmd.networkids.append(neto.id)
cmd.templateid = temp[0].id
cmd.hypervisor = self.hypervisor
ret = self.apiclient.deployVirtualMachine(cmd)
self.vms.append(ret.id)
time.sleep(20)
self.log.success()
def instances_in_network(self, name):
instances = []
self.log.ptest("Getting virtual machines in %s" % name)
for inst in self.list_instances():
for nic in inst.nic:
if nic.networkname.startswith(name):
instances.append(inst)
self.log.extra("[Found %s]" % len(instances))
self.log.success()
return instances
def destroy_instance(self, id):
if self.options.no_destroy:
return
self.log.ptest("Destroy virtual machine %s" % (id))
cmd = destroyVirtualMachine.destroyVirtualMachineCmd()
cmd.id = id
cmd.expunge = True
self.apiclient.destroyVirtualMachine(cmd)
time.sleep(20)
self.log.success()
def destroy_network(self, id):
if self.options.no_destroy:
return
self.log.ptest("Destroy network %s" % (id))
cmd = deleteNetwork.deleteNetworkCmd()
cmd.id = id
cmd.expunge = True
self.apiclient.deleteNetwork(cmd)
time.sleep(20)
self.log.success()
def destroy_vpc(self, id):
if self.options.no_destroy:
return
self.log.ptest("Detroying VPC %s" % id)
cmd = deleteVPC.deleteVPCCmd()
cmd.id = id
ret = self.apiclient.deleteVPC(cmd)
time.sleep(20)
self.log.success()
def destroy_all_vpcs(self):
for id in self.vpcs:
self.destroy_vpc(id)
def destroy_all(self):
for id in self.vms:
self.destroy_instance(id)
for id in self.networks:
self.destroy_network(id)
self.vms = []
self.networks = []
def list_firewall_rules(self, index, sport, eport):
cmd = listFirewallRules.listFirewallRulesCmd()
ret = self.apiclient.listFirewallRules(cmd)
if ret is None:
return ret
for rule in ret:
if rule.startport == str(sport) and rule.endport == str(eport) and self.ips[index].id == rule.ipaddressid:
return rule
return None
def delete_firewall_rule(self, index, sport, eport):
self.log.ptest("Deleting Firewall rule %s %s %s" % (self.ips[index].ipaddress, sport, eport))
self.comm.update_firewall(self.ips[index].ipaddress, sport, eport, False)
rule = self.list_firewall_rules(index, sport, eport)
if rule is None:
self.log.extra("Not There")
self.log.success()
return
cmd = deleteFirewallRule.deleteFirewallRuleCmd()
cmd.id = rule.id
self.apiclient.deleteFirewallRule(cmd)
self.log.success()
def add_firewall_rule(self, index, sport, eport):
self.log.ptest("Adding Firewall rule %s %s %s" % (self.ips[index].ipaddress, sport, eport))
self.comm.update_firewall(self.ips[index].ipaddress, sport, eport, True)
if self.list_firewall_rules(index, sport, eport) is not None:
self.log.extra("Exists")
self.log.success()
return
cmd = createFirewallRule.createFirewallRuleCmd()
cmd.cidrlist = "0.0.0.0/0"
cmd.protocol = "tcp"
cmd.startport = sport
cmd.endport = eport
cmd.ipaddressid = self.ips[index].id
self.apiclient.createFirewallRule(cmd)
self.log.success()
def enable_offering(self, off):
self.log.ptest("Enabling network offering %s" % off.name)
if off.state == "Enabled":
self.log.extra("Already Enabled")
self.log.success()
return
cmd = updateNetworkOffering.updateNetworkOfferingCmd()
cmd.id = off.id
cmd.state = "Enabled"
self.apiclient.updateNetworkOffering(cmd)
self.log.success()
def add_redundant_service_offering(self, name="isored1"):
self.log.ptest("Adding redundant isolated network offering (%s)" % name)
off = self.list_network_offerings(name)
if off is not None:
self.log.extra("Exists")
self.log.success()
self.enable_offering(off)
return off
cmd = createNetworkOffering.createNetworkOfferingCmd()
cmd.name = name
cmd.displaytext = name
cmd.ispersistent = "true"
cmd.guestiptype = "Isolated"
cmd.supportedservices = "Vpn,Dhcp,Dns,Firewall,Lb,SourceNat,StaticNat,PortForwarding"
cmd.servicecapabilitylist = []
cmd.servicecapabilitylist.append({
"service": "SourceNat",
"capabilitytype": "RedundantRouter",
"capabilityvalue": "true"
})
cmd.servicecapabilitylist.append({
"service": "SourceNat",
"capabilitytype": "SupportedSourceNatTypes",
"capabilityvalue": "peraccount"
})
cmd.servicecapabilitylist.append({
"service": "lb",
"capabilitytype": "SupportedLbIsolation",
"capabilityvalue": "dedicated"
})
cmd.serviceproviderlist = []
cmd.serviceproviderlist.append({"service": "Vpn", "provider": "VirtualRouter"})
cmd.serviceproviderlist.append({"service": "Dhcp", "provider": "VirtualRouter"})
cmd.serviceproviderlist.append({"service": "Dns", "provider": "VirtualRouter"})
cmd.serviceproviderlist.append({"service": "Firewall", "provider": "VirtualRouter"})
cmd.serviceproviderlist.append({"service": "Lb", "provider": "VirtualRouter"})
cmd.serviceproviderlist.append({"service": "SourceNat", "provider": "VirtualRouter"})
cmd.serviceproviderlist.append({"service": "StaticNat", "provider": "VirtualRouter"})
cmd.serviceproviderlist.append({"service": "PortForwarding", "provider": "VirtualRouter"})
cmd.traffictype = "GUEST"
off = self.apiclient.createNetworkOffering(cmd)
self.log.success()
self.enable_offering(off)
return off
