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
lz.available = True resp = apiclient.listZones(lz) zone = resp[0] # Create Network lno = listNetworkOfferings.listNetworkOfferingsCmd() lno.name="DefaultIsolatedNetworkOfferingWithSourceNatService" resp = apiclient.listNetworkOfferings(lno) offering = resp[0] cn = createNetwork.createNetworkCmd() cn.name = "test_isolated" cn.displaytext = "Test Isolated" cn.networkofferingid = offering.id cn.zoneid = zone.id network = apiclient.createNetwork(cn) # Create Instance lt = listTemplates.listTemplatesCmd() lt.name = "tiny Linux" lt.templatefilter="all" resp = apiclient.listTemplates(lt) template = resp[0] lso = listServiceOfferings.listServiceOfferingsCmd() lso.name = "tinyOffering" resp = apiclient.listServiceOfferings(lso) serviceOffering = resp[0] dv = deployVirtualMachine.deployVirtualMachineCmd() dv.zoneid = zone.id