http://git-wip-us.apache.org/repos/asf/cloudstack/blob/d002c52a/tools/marvin/marvin/lib/base.py ---------------------------------------------------------------------- diff --git a/tools/marvin/marvin/lib/base.py b/tools/marvin/marvin/lib/base.py deleted file mode 100755 index 38a04db..0000000 --- a/tools/marvin/marvin/lib/base.py +++ /dev/null @@ -1,4716 +0,0 @@ -# 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. - -""" Base class for all Cloudstack resources - -Virtual machine, Volume, Snapshot etc -""" - -import marvin -from marvin.cloudstackAPI import * -from marvin.codes import (FAILED, FAIL, PASS, RUNNING, STOPPED, - STARTING, DESTROYED, EXPUNGING, - STOPPING, BACKED_UP, BACKING_UP) -from marvin.cloudstackException import GetDetailExceptionInfo, CloudstackAPIException -from marvin.lib.utils import validateList, is_server_ssh_ready, random_gen -# Import System modules -import time -import hashlib -import base64 - - -class Domain: - """ Domain Life Cycle """ - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, name=None, networkdomain=None, - parentdomainid=None): - """Creates an domain""" - - cmd = createDomain.createDomainCmd() - - if "domainUUID" in services: - cmd.domainid = "-".join([services["domainUUID"], random_gen()]) - - if name: - cmd.name = "-".join([name, random_gen()]) - elif "name" in services: - cmd.name = "-".join([services["name"], random_gen()]) - - if networkdomain: - cmd.networkdomain = networkdomain - elif "networkdomain" in services: - cmd.networkdomain = services["networkdomain"] - - if parentdomainid: - cmd.parentdomainid = parentdomainid - elif "parentdomainid" in services: - cmd.parentdomainid = services["parentdomainid"] - try: - domain = apiclient.createDomain(cmd) - if domain is not None: - return Domain(domain.__dict__) - except Exception as e: - raise e - - def delete(self, apiclient, cleanup=None): - """Delete an domain""" - cmd = deleteDomain.deleteDomainCmd() - cmd.id = self.id - if cleanup: - cmd.cleanup = cleanup - apiclient.deleteDomain(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """Lists domains""" - cmd = listDomains.listDomainsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listDomains(cmd)) - - -class Account: - """ Account Life Cycle """ - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, admin=False, domainid=None): - """Creates an account""" - cmd = createAccount.createAccountCmd() - - # 0 - User, 1 - Root Admin, 2 - Domain Admin - cmd.accounttype = 2 if (admin and domainid) else int(admin) - - cmd.email = services["email"] - cmd.firstname = services["firstname"] - cmd.lastname = services["lastname"] - - cmd.password = services["password"] - username = services["username"] - # Limit account username to 99 chars to avoid failure - # 6 chars start string + 85 chars apiclientid + 6 chars random string + 2 chars joining hyphen string = 99 - username = username[:6] - apiclientid = apiclient.id[-85:] if len(apiclient.id) > 85 else apiclient.id - cmd.username = "-".join([username, - random_gen(id=apiclientid, size=6)]) - - if "accountUUID" in services: - cmd.accountid = "-".join([services["accountUUID"], random_gen()]) - - if "userUUID" in services: - cmd.userid = "-".join([services["userUUID"], random_gen()]) - - - if domainid: - cmd.domainid = domainid - account = apiclient.createAccount(cmd) - - return Account(account.__dict__) - - def delete(self, apiclient): - """Delete an account""" - cmd = deleteAccount.deleteAccountCmd() - cmd.id = self.id - apiclient.deleteAccount(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """Lists accounts and provides detailed account information for - listed accounts""" - - cmd = listAccounts.listAccountsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listAccounts(cmd)) - - def disable(self, apiclient, lock=False): - """Disable an account""" - cmd = disableAccount.disableAccountCmd() - cmd.id = self.id - cmd.lock = lock - apiclient.disableAccount(cmd) - - -class User: - """ User Life Cycle """ - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, account, domainid): - cmd = createUser.createUserCmd() - """Creates an user""" - - cmd.account = account - cmd.domainid = domainid - cmd.email = services["email"] - cmd.firstname = services["firstname"] - cmd.lastname = services["lastname"] - - if "userUUID" in services: - cmd.userid = "-".join([services["userUUID"], random_gen()]) - - cmd.password = services["password"] - cmd.username = "-".join([services["username"], random_gen()]) - user = apiclient.createUser(cmd) - - return User(user.__dict__) - - def delete(self, apiclient): - """Delete an account""" - cmd = deleteUser.deleteUserCmd() - cmd.id = self.id - apiclient.deleteUser(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """Lists users and provides detailed account information for - listed users""" - - cmd = listUsers.listUsersCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listUsers(cmd)) - - @classmethod - def registerUserKeys(cls, apiclient, userid): - cmd = registerUserKeys.registerUserKeysCmd() - cmd.id = userid - return apiclient.registerUserKeys(cmd) - - def update(self, apiclient, **kwargs): - """Updates the user details""" - - cmd = updateUser.updateUserCmd() - cmd.id = self.id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return (apiclient.updateUser(cmd)) - - @classmethod - def update(cls, apiclient, id, **kwargs): - """Updates the user details (class method)""" - - cmd = updateUser.updateUserCmd() - cmd.id = id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return (apiclient.updateUser(cmd)) - - @classmethod - def login(cls, apiclient, username, password, domain=None, domainid=None): - """Logins to the CloudStack""" - - cmd = login.loginCmd() - cmd.username = username - cmd.password = password - if domain: - cmd.domain = domain - if domainid: - cmd.domainId = domainid - return apiclient.login(cmd) - - -class VirtualMachine: - """Manage virtual machine lifecycle""" - - '''Class level variables''' - # Variables denoting VM state - start - STOPPED = STOPPED - RUNNING = RUNNING - DESTROYED = DESTROYED - EXPUNGING = EXPUNGING - STOPPING = STOPPING - STARTING = STARTING - # Varibles denoting VM state - end - - def __init__(self, items, services): - self.__dict__.update(items) - if "username" in services: - self.username = services["username"] - else: - self.username = 'root' - if "password" in services: - self.password = services["password"] - else: - self.password = 'password' - if "ssh_port" in services: - self.ssh_port = services["ssh_port"] - else: - self.ssh_port = 22 - self.ssh_client = None - # extract out the ipaddress - self.ipaddress = self.nic[0].ipaddress - - @classmethod - def ssh_access_group(cls, apiclient, cmd): - """ - Programs the security group with SSH - access before deploying virtualmachine - @return: - """ - zone_list = Zone.list( - apiclient, - id=cmd.zoneid if cmd.zoneid else None, - domainid=cmd.domainid if cmd.domainid else None - ) - zone = zone_list[0] - # check if security groups settings is enabled for the zone - if zone.securitygroupsenabled: - list_security_groups = SecurityGroup.list( - apiclient, - account=cmd.account, - domainid=cmd.domainid, - listall=True, - securitygroupname="basic_sec_grp" - ) - - if not isinstance(list_security_groups, list): - basic_mode_security_group = SecurityGroup.create( - apiclient, - {"name": "basic_sec_grp"}, - cmd.account, - cmd.domainid, - ) - sec_grp_services = { - "protocol": "TCP", - "startport": 22, - "endport": 22, - "cidrlist": "0.0.0.0/0" - } - # Authorize security group for above ingress rule - basic_mode_security_group.authorize(apiclient, - sec_grp_services, - account=cmd.account, - domainid=cmd.domainid) - else: - basic_mode_security_group = list_security_groups[0] - - if isinstance(cmd.securitygroupids, list): - cmd.securitygroupids.append(basic_mode_security_group.id) - else: - cmd.securitygroupids = [basic_mode_security_group.id] - - @classmethod - def access_ssh_over_nat( - cls, apiclient, services, virtual_machine, allow_egress=False, - networkid=None): - """ - Program NAT and PF rules to open up ssh access to deployed guest - @return: - """ - public_ip = PublicIPAddress.create( - apiclient=apiclient, - accountid=virtual_machine.account, - zoneid=virtual_machine.zoneid, - domainid=virtual_machine.domainid, - services=services, - networkid=networkid - ) - FireWallRule.create( - apiclient=apiclient, - ipaddressid=public_ip.ipaddress.id, - protocol='TCP', - cidrlist=['0.0.0.0/0'], - startport=22, - endport=22 - ) - nat_rule = NATRule.create( - apiclient=apiclient, - virtual_machine=virtual_machine, - services=services, - ipaddressid=public_ip.ipaddress.id - ) - if allow_egress: - try: - EgressFireWallRule.create( - apiclient=apiclient, - networkid=virtual_machine.nic[0].networkid, - protocol='All', - cidrlist='0.0.0.0/0' - ) - except CloudstackAPIException, e: - # This could fail because we've already set up the same rule - if not "There is already a firewall rule specified".lower() in e.errorMsg.lower(): - raise - virtual_machine.ssh_ip = nat_rule.ipaddress - virtual_machine.public_ip = nat_rule.ipaddress - - @classmethod - def create(cls, apiclient, services, templateid=None, accountid=None, - domainid=None, zoneid=None, networkids=None, - serviceofferingid=None, securitygroupids=None, - projectid=None, startvm=None, diskofferingid=None, - affinitygroupnames=None, affinitygroupids=None, group=None, - hostid=None, keypair=None, ipaddress=None, mode='default', - method='GET', hypervisor=None, customcpunumber=None, - customcpuspeed=None, custommemory=None, rootdisksize=None): - """Create the instance""" - - cmd = deployVirtualMachine.deployVirtualMachineCmd() - - if serviceofferingid: - cmd.serviceofferingid = serviceofferingid - elif "serviceoffering" in services: - cmd.serviceofferingid = services["serviceoffering"] - - if zoneid: - cmd.zoneid = zoneid - elif "zoneid" in services: - cmd.zoneid = services["zoneid"] - - if hypervisor: - cmd.hypervisor = hypervisor - - if "displayname" in services: - cmd.displayname = services["displayname"] - - if "name" in services: - cmd.name = services["name"] - - if accountid: - cmd.account = accountid - elif "account" in services: - cmd.account = services["account"] - - if domainid: - cmd.domainid = domainid - elif "domainid" in services: - cmd.domainid = services["domainid"] - - if networkids: - cmd.networkids = networkids - allow_egress = False - elif "networkids" in services: - cmd.networkids = services["networkids"] - allow_egress = False - else: - # When no networkids are passed, network - # is created using the "defaultOfferingWithSourceNAT" - # which has an egress policy of DENY. But guests in tests - # need access to test network connectivity - allow_egress = True - - if templateid: - cmd.templateid = templateid - elif "template" in services: - cmd.templateid = services["template"] - - if diskofferingid: - cmd.diskofferingid = diskofferingid - elif "diskoffering" in services: - cmd.diskofferingid = services["diskoffering"] - - if keypair: - cmd.keypair = keypair - elif "keypair" in services: - cmd.keypair = services["keypair"] - - if ipaddress: - cmd.ipaddress = ipaddress - elif ipaddress in services: - cmd.ipaddress = services["ipaddress"] - - if securitygroupids: - cmd.securitygroupids = [str(sg_id) for sg_id in securitygroupids] - - if "affinitygroupnames" in services: - cmd.affinitygroupnames = services["affinitygroupnames"] - elif affinitygroupnames: - cmd.affinitygroupnames = affinitygroupnames - - if affinitygroupids: - cmd.affinitygroupids = affinitygroupids - - if projectid: - cmd.projectid = projectid - - if startvm is not None: - cmd.startvm = startvm - - if hostid: - cmd.hostid = hostid - - if "userdata" in services: - cmd.userdata = base64.urlsafe_b64encode(services["userdata"]) - - cmd.details = [{}] - - if customcpunumber: - cmd.details[0]["cpuNumber"] = customcpunumber - - if customcpuspeed: - cmd.details[0]["cpuSpeed"] = customcpuspeed - - if custommemory: - cmd.details[0]["memory"] = custommemory - - if rootdisksize >= 0: - cmd.details[0]["rootdisksize"] = rootdisksize - - if group: - cmd.group = group - - # program default access to ssh - if mode.lower() == 'basic': - cls.ssh_access_group(apiclient, cmd) - - virtual_machine = apiclient.deployVirtualMachine(cmd, method=method) - - virtual_machine.ssh_ip = virtual_machine.nic[0].ipaddress - if startvm is False: - virtual_machine.public_ip = virtual_machine.nic[0].ipaddress - return VirtualMachine(virtual_machine.__dict__, services) - - # program ssh access over NAT via PF - if mode.lower() == 'advanced': - cls.access_ssh_over_nat( - apiclient, - services, - virtual_machine, - allow_egress=allow_egress, - networkid=cmd.networkids[0] if cmd.networkids else None) - elif mode.lower() == 'basic': - if virtual_machine.publicip is not None: - # EIP/ELB (netscaler) enabled zone - vm_ssh_ip = virtual_machine.publicip - else: - # regular basic zone with security group - vm_ssh_ip = virtual_machine.nic[0].ipaddress - virtual_machine.ssh_ip = vm_ssh_ip - virtual_machine.public_ip = vm_ssh_ip - - return VirtualMachine(virtual_machine.__dict__, services) - - @classmethod - def createSmallVm(cls, testClient, ): - virtual_machine = VirtualMachine.create( - testClient.getApiclient(), - testClient.getCSConfig.getDefaultSmallDiskOffering(), - accountid=cls.account.name, - domainid=cls.account.domainid, - serviceofferingid=cls.service_offering.id, - mode=cls.services['mode'] - ) - - def start(self, apiclient): - """Start the instance""" - cmd = startVirtualMachine.startVirtualMachineCmd() - cmd.id = self.id - apiclient.startVirtualMachine(cmd) - response = self.getState(apiclient, VirtualMachine.RUNNING) - if response[0] == FAIL: - raise Exception(response[1]) - return - - def stop(self, apiclient, forced=None): - """Stop the instance""" - cmd = stopVirtualMachine.stopVirtualMachineCmd() - cmd.id = self.id - if forced: - cmd.forced = forced - apiclient.stopVirtualMachine(cmd) - response = self.getState(apiclient, VirtualMachine.STOPPED) - if response[0] == FAIL: - raise Exception(response[1]) - return - - def reboot(self, apiclient): - """Reboot the instance""" - cmd = rebootVirtualMachine.rebootVirtualMachineCmd() - cmd.id = self.id - apiclient.rebootVirtualMachine(cmd) - - def recover(self, apiclient): - """Recover the instance""" - cmd = recoverVirtualMachine.recoverVirtualMachineCmd() - cmd.id = self.id - apiclient.recoverVirtualMachine(cmd) - - def restore(self, apiclient, templateid=None): - """Restore the instance""" - cmd = restoreVirtualMachine.restoreVirtualMachineCmd() - cmd.virtualmachineid = self.id - if templateid: - cmd.templateid = templateid - return apiclient.restoreVirtualMachine(cmd) - - def get_ssh_client( - self, ipaddress=None, reconnect=False, port=None, - keyPairFileLocation=None): - """Get SSH object of VM""" - - # If NAT Rules are not created while VM deployment in Advanced mode - # then, IP address must be passed - if ipaddress is not None: - self.ssh_ip = ipaddress - if port: - self.ssh_port = port - - if keyPairFileLocation is not None: - self.password = None - - if reconnect: - self.ssh_client = is_server_ssh_ready( - self.ssh_ip, - self.ssh_port, - self.username, - self.password, - keyPairFileLocation=keyPairFileLocation - ) - self.ssh_client = self.ssh_client or is_server_ssh_ready( - self.ssh_ip, - self.ssh_port, - self.username, - self.password, - keyPairFileLocation=keyPairFileLocation - ) - return self.ssh_client - - def getState(self, apiclient, state, timeout=600): - """List VM and check if its state is as expected - @returnValue - List[Result, Reason] - 1) Result - FAIL if there is any exception - in the operation or VM state does not change - to expected state in given time else PASS - 2) Reason - Reason for failure""" - - returnValue = [FAIL, "VM state not trasited to %s,\ - operation timed out" % state] - - while timeout > 0: - try: - projectid = None - if hasattr(self, "projectid"): - projectid = self.projectid - vms = VirtualMachine.list(apiclient, projectid=projectid, - id=self.id, listAll=True) - validationresult = validateList(vms) - if validationresult[0] == FAIL: - raise Exception("VM list validation failed: %s" % validationresult[2]) - elif str(vms[0].state).lower().decode("string_escape") == str(state).lower(): - returnValue = [PASS, None] - break - except Exception as e: - returnValue = [FAIL, e] - break - time.sleep(60) - timeout -= 60 - return returnValue - - def resetSshKey(self, apiclient, **kwargs): - """Resets SSH key""" - - cmd = resetSSHKeyForVirtualMachine.resetSSHKeyForVirtualMachineCmd() - cmd.id = self.id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.resetSSHKeyForVirtualMachine(cmd)) - - def update(self, apiclient, **kwargs): - """Updates the VM data""" - - cmd = updateVirtualMachine.updateVirtualMachineCmd() - cmd.id = self.id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.updateVirtualMachine(cmd)) - - def delete(self, apiclient, expunge=True, **kwargs): - """Destroy an Instance""" - cmd = destroyVirtualMachine.destroyVirtualMachineCmd() - cmd.id = self.id - cmd.expunge = expunge - [setattr(cmd, k, v) for k, v in kwargs.items()] - apiclient.destroyVirtualMachine(cmd) - - def expunge(self, apiclient): - """Expunge an Instance""" - cmd = expungeVirtualMachine.expungeVirtualMachineCmd() - cmd.id = self.id - apiclient.expungeVirtualMachine(cmd) - - def migrate(self, apiclient, hostid=None): - """migrate an Instance""" - cmd = migrateVirtualMachine.migrateVirtualMachineCmd() - cmd.virtualmachineid = self.id - if hostid: - cmd.hostid = hostid - apiclient.migrateVirtualMachine(cmd) - - def attach_volume(self, apiclient, volume): - """Attach volume to instance""" - cmd = attachVolume.attachVolumeCmd() - cmd.id = volume.id - cmd.virtualmachineid = self.id - return apiclient.attachVolume(cmd) - - def detach_volume(self, apiclient, volume): - """Detach volume to instance""" - cmd = detachVolume.detachVolumeCmd() - cmd.id = volume.id - return apiclient.detachVolume(cmd) - - def add_nic(self, apiclient, networkId, ipaddress=None): - """Add a NIC to a VM""" - cmd = addNicToVirtualMachine.addNicToVirtualMachineCmd() - cmd.virtualmachineid = self.id - cmd.networkid = networkId - - if ipaddress: - cmd.ipaddress = ipaddress - - return apiclient.addNicToVirtualMachine(cmd) - - def remove_nic(self, apiclient, nicId): - """Remove a NIC to a VM""" - cmd = removeNicFromVirtualMachine.removeNicFromVirtualMachineCmd() - cmd.nicid = nicId - cmd.virtualmachineid = self.id - return apiclient.removeNicFromVirtualMachine(cmd) - - def update_default_nic(self, apiclient, nicId): - """Set a NIC to be the default network adapter for a VM""" - cmd = updateDefaultNicForVirtualMachine.\ - updateDefaultNicForVirtualMachineCmd() - cmd.nicid = nicId - cmd.virtualmachineid = self.id - return apiclient.updateDefaultNicForVirtualMachine(cmd) - - def attach_iso(self, apiclient, iso): - """Attach ISO to instance""" - cmd = attachIso.attachIsoCmd() - cmd.id = iso.id - cmd.virtualmachineid = self.id - return apiclient.attachIso(cmd) - - def detach_iso(self, apiclient): - """Detach ISO to instance""" - cmd = detachIso.detachIsoCmd() - cmd.virtualmachineid = self.id - return apiclient.detachIso(cmd) - - def scale_virtualmachine(self, apiclient, serviceOfferingId): - """ Scale up of service offering for the Instance""" - cmd = scaleVirtualMachine.scaleVirtualMachineCmd() - cmd.id = self.id - cmd.serviceofferingid = serviceOfferingId - return apiclient.scaleVirtualMachine(cmd) - - def change_service_offering(self, apiclient, serviceOfferingId): - """Change service offering of the instance""" - cmd = changeServiceForVirtualMachine.\ - changeServiceForVirtualMachineCmd() - cmd.id = self.id - cmd.serviceofferingid = serviceOfferingId - return apiclient.changeServiceForVirtualMachine(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """List all VMs matching criteria""" - - cmd = listVirtualMachines.listVirtualMachinesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listVirtualMachines(cmd)) - - def resetPassword(self, apiclient): - """Resets VM password if VM created using password enabled template""" - - cmd = resetPasswordForVirtualMachine.\ - resetPasswordForVirtualMachineCmd() - cmd.id = self.id - try: - response = apiclient.resetPasswordForVirtualMachine(cmd) - except Exception as e: - raise Exception("Reset Password failed! - %s" % e) - if response is not None: - return response.password - - def assign_virtual_machine(self, apiclient, account, domainid): - """Move a user VM to another user under same domain.""" - - cmd = assignVirtualMachine.assignVirtualMachineCmd() - cmd.virtualmachineid = self.id - cmd.account = account - cmd.domainid = domainid - try: - response = apiclient.assignVirtualMachine(cmd) - return response - except Exception as e: - raise Exception("assignVirtualMachine failed - %s" % e) - - def update_affinity_group(self, apiclient, affinitygroupids=None, - affinitygroupnames=None): - """Update affinity group of a VM""" - cmd = updateVMAffinityGroup.updateVMAffinityGroupCmd() - cmd.id = self.id - - if affinitygroupids: - cmd.affinitygroupids = affinitygroupids - - if affinitygroupnames: - cmd.affinitygroupnames = affinitygroupnames - - return apiclient.updateVMAffinityGroup(cmd) - - def scale(self, apiclient, serviceOfferingId, - customcpunumber=None, customcpuspeed=None, custommemory=None): - """Change service offering of the instance""" - cmd = scaleVirtualMachine.scaleVirtualMachineCmd() - cmd.id = self.id - cmd.serviceofferingid = serviceOfferingId - cmd.details = [{"cpuNumber": "", "cpuSpeed": "", "memory": ""}] - if customcpunumber: - cmd.details[0]["cpuNumber"] = customcpunumber - if customcpuspeed: - cmd.details[0]["cpuSpeed"] = customcpuspeed - if custommemory: - cmd.details[0]["memory"] = custommemory - return apiclient.scaleVirtualMachine(cmd) - - -class Volume: - """Manage Volume Life cycle - """ - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, zoneid=None, account=None, - domainid=None, diskofferingid=None, projectid=None): - """Create Volume""" - cmd = createVolume.createVolumeCmd() - cmd.name = services["diskname"] - - if diskofferingid: - cmd.diskofferingid = diskofferingid - elif "diskofferingid" in services: - cmd.diskofferingid = services["diskofferingid"] - - if zoneid: - cmd.zoneid = zoneid - elif "zoneid" in services: - cmd.zoneid = services["zoneid"] - - if account: - cmd.account = account - elif "account" in services: - cmd.account = services["account"] - - if domainid: - cmd.domainid = domainid - elif "domainid" in services: - cmd.domainid = services["domainid"] - - if projectid: - cmd.projectid = projectid - return Volume(apiclient.createVolume(cmd).__dict__) - - @classmethod - def create_custom_disk(cls, apiclient, services, account=None, - domainid=None, diskofferingid=None): - """Create Volume from Custom disk offering""" - cmd = createVolume.createVolumeCmd() - cmd.name = services["diskname"] - - if diskofferingid: - cmd.diskofferingid = diskofferingid - elif "customdiskofferingid" in services: - cmd.diskofferingid = services["customdiskofferingid"] - - cmd.size = services["customdisksize"] - cmd.zoneid = services["zoneid"] - - if account: - cmd.account = account - else: - cmd.account = services["account"] - - if domainid: - cmd.domainid = domainid - else: - cmd.domainid = services["domainid"] - - return Volume(apiclient.createVolume(cmd).__dict__) - - @classmethod - def create_from_snapshot(cls, apiclient, snapshot_id, services, - account=None, domainid=None): - """Create Volume from snapshot""" - cmd = createVolume.createVolumeCmd() - cmd.name = "-".join([services["diskname"], random_gen()]) - cmd.snapshotid = snapshot_id - cmd.zoneid = services["zoneid"] - cmd.size = services["size"] - if account: - cmd.account = account - else: - cmd.account = services["account"] - if domainid: - cmd.domainid = domainid - else: - cmd.domainid = services["domainid"] - return Volume(apiclient.createVolume(cmd).__dict__) - - def delete(self, apiclient): - """Delete Volume""" - cmd = deleteVolume.deleteVolumeCmd() - cmd.id = self.id - apiclient.deleteVolume(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """List all volumes matching criteria""" - - cmd = listVolumes.listVolumesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listVolumes(cmd)) - - def resize(self, apiclient, **kwargs): - """Resize a volume""" - cmd = resizeVolume.resizeVolumeCmd() - cmd.id = self.id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.resizeVolume(cmd)) - - @classmethod - def upload(cls, apiclient, services, zoneid=None, - account=None, domainid=None, url=None): - """Uploads the volume to specified account""" - - cmd = uploadVolume.uploadVolumeCmd() - if zoneid: - cmd.zoneid = zoneid - if account: - cmd.account = account - if domainid: - cmd.domainid = domainid - cmd.format = services["format"] - cmd.name = services["diskname"] - if url: - cmd.url = url - else: - cmd.url = services["url"] - return Volume(apiclient.uploadVolume(cmd).__dict__) - - def wait_for_upload(self, apiclient, timeout=10, interval=60): - """Wait for upload""" - # Sleep to ensure template is in proper state before download - time.sleep(interval) - - while True: - volume_response = Volume.list( - apiclient, - id=self.id, - zoneid=self.zoneid, - ) - if isinstance(volume_response, list): - - volume = volume_response[0] - # If volume is ready, - # volume.state = Allocated - if volume.state == 'Uploaded': - break - - elif 'Uploading' in volume.state: - time.sleep(interval) - - elif 'Installing' not in volume.state: - raise Exception( - "Error in uploading volume: status - %s" % - volume.state) - elif timeout == 0: - break - - else: - time.sleep(interval) - timeout = timeout - 1 - return - - @classmethod - def extract(cls, apiclient, volume_id, zoneid, mode): - """Extracts the volume""" - - cmd = extractVolume.extractVolumeCmd() - cmd.id = volume_id - cmd.zoneid = zoneid - cmd.mode = mode - return Volume(apiclient.extractVolume(cmd).__dict__) - - @classmethod - def migrate(cls, apiclient, **kwargs): - """Migrate a volume""" - cmd = migrateVolume.migrateVolumeCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.migrateVolume(cmd)) - -class Snapshot: - """Manage Snapshot Lifecycle - """ - '''Class level variables''' - # Variables denoting possible Snapshot states - start - BACKED_UP = BACKED_UP - BACKING_UP = BACKING_UP - # Variables denoting possible Snapshot states - end - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, volume_id, account=None, - domainid=None, projectid=None): - """Create Snapshot""" - cmd = createSnapshot.createSnapshotCmd() - cmd.volumeid = volume_id - if account: - cmd.account = account - if domainid: - cmd.domainid = domainid - if projectid: - cmd.projectid = projectid - return Snapshot(apiclient.createSnapshot(cmd).__dict__) - - def delete(self, apiclient): - """Delete Snapshot""" - cmd = deleteSnapshot.deleteSnapshotCmd() - cmd.id = self.id - apiclient.deleteSnapshot(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """List all snapshots matching criteria""" - - cmd = listSnapshots.listSnapshotsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listSnapshots(cmd)) - - def validateState(self, apiclient, snapshotstate, timeout=600): - """Check if snapshot is in required state - returnValue: List[Result, Reason] - @Result: PASS if snapshot is in required state, - else FAIL - @Reason: Reason for failure in case Result is FAIL - """ - isSnapshotInRequiredState = False - try: - while timeout >= 0: - snapshots = Snapshot.list(apiclient, id=self.id) - assert validateList(snapshots)[0] == PASS, "snapshots list\ - validation failed" - if str(snapshots[0].state).lower() == snapshotstate: - isSnapshotInRequiredState = True - break - timeout -= 60 - time.sleep(60) - #end while - if isSnapshotInRequiredState: - return[PASS, None] - else: - raise Exception("Snapshot not in required state") - except Exception as e: - return [FAIL, e] - -class Template: - """Manage template life cycle""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, volumeid=None, - account=None, domainid=None, projectid=None): - """Create template from Volume""" - # Create template from Virtual machine and Volume ID - cmd = createTemplate.createTemplateCmd() - cmd.displaytext = services["displaytext"] - cmd.name = "-".join([services["name"], random_gen()]) - if "ostypeid" in services: - cmd.ostypeid = services["ostypeid"] - elif "ostype" in services: - # Find OSTypeId from Os type - sub_cmd = listOsTypes.listOsTypesCmd() - sub_cmd.description = services["ostype"] - ostypes = apiclient.listOsTypes(sub_cmd) - - if not isinstance(ostypes, list): - raise Exception( - "Unable to find Ostype id with desc: %s" % - services["ostype"]) - cmd.ostypeid = ostypes[0].id - else: - raise Exception( - "Unable to find Ostype is required for creating template") - - cmd.isfeatured = services[ - "isfeatured"] if "isfeatured" in services else False - cmd.ispublic = services[ - "ispublic"] if "ispublic" in services else False - cmd.isextractable = services[ - "isextractable"] if "isextractable" in services else False - cmd.passwordenabled = services[ - "passwordenabled"] if "passwordenabled" in services else False - - if volumeid: - cmd.volumeid = volumeid - - if account: - cmd.account = account - - if domainid: - cmd.domainid = domainid - - if projectid: - cmd.projectid = projectid - return Template(apiclient.createTemplate(cmd).__dict__) - - @classmethod - def register(cls, apiclient, services, zoneid=None, - account=None, domainid=None, hypervisor=None, - projectid=None): - """Create template from URL""" - - # Create template from Virtual machine and Volume ID - cmd = registerTemplate.registerTemplateCmd() - cmd.displaytext = services["displaytext"] - cmd.name = "-".join([services["name"], random_gen()]) - cmd.format = services["format"] - if hypervisor: - cmd.hypervisor = hypervisor - elif "hypervisor" in services: - cmd.hypervisor = services["hypervisor"] - - if "ostypeid" in services: - cmd.ostypeid = services["ostypeid"] - elif "ostype" in services: - # Find OSTypeId from Os type - sub_cmd = listOsTypes.listOsTypesCmd() - sub_cmd.description = services["ostype"] - ostypes = apiclient.listOsTypes(sub_cmd) - - if not isinstance(ostypes, list): - raise Exception( - "Unable to find Ostype id with desc: %s" % - services["ostype"]) - cmd.ostypeid = ostypes[0].id - else: - raise Exception( - "Unable to find Ostype is required for registering template") - - cmd.url = services["url"] - - if zoneid: - cmd.zoneid = zoneid - else: - cmd.zoneid = services["zoneid"] - - cmd.isfeatured = services[ - "isfeatured"] if "isfeatured" in services else False - cmd.ispublic = services[ - "ispublic"] if "ispublic" in services else False - cmd.isextractable = services[ - "isextractable"] if "isextractable" in services else False - cmd.passwordenabled = services[ - "passwordenabled"] if "passwordenabled" in services else False - - if account: - cmd.account = account - - if domainid: - cmd.domainid = domainid - - if projectid: - cmd.projectid = projectid - elif "projectid" in services: - cmd.projectid = services["projectid"] - - # Register Template - template = apiclient.registerTemplate(cmd) - - if isinstance(template, list): - return Template(template[0].__dict__) - - @classmethod - def extract(cls, apiclient, id, mode, zoneid=None): - "Extract template " - - cmd = extractTemplate.extractTemplateCmd() - cmd.id = id - cmd.mode = mode - cmd.zoneid = zoneid - - return apiclient.extractTemplate(cmd) - - @classmethod - def create_from_snapshot(cls, apiclient, snapshot, services, - random_name=True): - """Create Template from snapshot""" - # Create template from Virtual machine and Snapshot ID - cmd = createTemplate.createTemplateCmd() - cmd.displaytext = services["displaytext"] - cmd.name = "-".join([ - services["name"], - random_gen() - ]) if random_name else services["name"] - - if "ostypeid" in services: - cmd.ostypeid = services["ostypeid"] - elif "ostype" in services: - # Find OSTypeId from Os type - sub_cmd = listOsTypes.listOsTypesCmd() - sub_cmd.description = services["ostype"] - ostypes = apiclient.listOsTypes(sub_cmd) - - if not isinstance(ostypes, list): - raise Exception( - "Unable to find Ostype id with desc: %s" % - services["ostype"]) - cmd.ostypeid = ostypes[0].id - else: - raise Exception( - "Unable to find Ostype is required for creating template") - - cmd.snapshotid = snapshot.id - return Template(apiclient.createTemplate(cmd).__dict__) - - def delete(self, apiclient): - """Delete Template""" - - cmd = deleteTemplate.deleteTemplateCmd() - cmd.id = self.id - apiclient.deleteTemplate(cmd) - - def download(self, apiclient, timeout=5, interval=60): - """Download Template""" - # Sleep to ensure template is in proper state before download - time.sleep(interval) - - while True: - template_response = Template.list( - apiclient, - id=self.id, - zoneid=self.zoneid, - templatefilter='self' - ) - if isinstance(template_response, list): - - template = template_response[0] - # If template is ready, - # template.status = Download Complete - # Downloading - x% Downloaded - # Error - Any other string - if template.status == 'Download Complete': - break - - elif 'Downloaded' in template.status: - time.sleep(interval) - - elif 'Installing' not in template.status: - raise Exception( - "Error in downloading template: status - %s" % - template.status) - - elif timeout == 0: - break - - else: - time.sleep(interval) - timeout = timeout - 1 - return - - def updatePermissions(self, apiclient, **kwargs): - """Updates the template permissions""" - - cmd = updateTemplatePermissions.updateTemplatePermissionsCmd() - cmd.id = self.id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.updateTemplatePermissions(cmd)) - - def update(self, apiclient, **kwargs): - """Updates the template details""" - - cmd = updateTemplate.updateTemplateCmd() - cmd.id = self.id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.updateTemplate(cmd)) - - @classmethod - def copy(cls, apiclient, id, sourcezoneid, destzoneid): - "Copy Template from source Zone to Destination Zone" - - cmd = copyTemplate.copyTemplateCmd() - cmd.id = id - cmd.sourcezoneid = sourcezoneid - cmd.destzoneid = destzoneid - - return apiclient.copyTemplate(cmd) - - def copy(self, apiclient, sourcezoneid, destzoneid): - "Copy Template from source Zone to Destination Zone" - - cmd = copyTemplate.copyTemplateCmd() - cmd.id = self.id - cmd.sourcezoneid = sourcezoneid - cmd.destzoneid = destzoneid - - return apiclient.copyTemplate(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """List all templates matching criteria""" - - cmd = listTemplates.listTemplatesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listTemplates(cmd)) - - -class Iso: - """Manage ISO life cycle""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, account=None, domainid=None, - projectid=None): - """Create an ISO""" - # Create ISO from URL - cmd = registerIso.registerIsoCmd() - cmd.displaytext = services["displaytext"] - cmd.name = services["name"] - if "ostypeid" in services: - cmd.ostypeid = services["ostypeid"] - elif "ostype" in services: - # Find OSTypeId from Os type - sub_cmd = listOsTypes.listOsTypesCmd() - sub_cmd.description = services["ostype"] - ostypes = apiclient.listOsTypes(sub_cmd) - - if not isinstance(ostypes, list): - raise Exception( - "Unable to find Ostype id with desc: %s" % - services["ostype"]) - cmd.ostypeid = ostypes[0].id - else: - raise Exception( - "Unable to find Ostype is required for creating ISO") - - cmd.url = services["url"] - cmd.zoneid = services["zoneid"] - - if "isextractable" in services: - cmd.isextractable = services["isextractable"] - if "isfeatured" in services: - cmd.isfeatured = services["isfeatured"] - if "ispublic" in services: - cmd.ispublic = services["ispublic"] - - if account: - cmd.account = account - if domainid: - cmd.domainid = domainid - if projectid: - cmd.projectid = projectid - # Register ISO - iso = apiclient.registerIso(cmd) - - if iso: - return Iso(iso[0].__dict__) - - def delete(self, apiclient): - """Delete an ISO""" - cmd = deleteIso.deleteIsoCmd() - cmd.id = self.id - apiclient.deleteIso(cmd) - return - - def download(self, apiclient, timeout=5, interval=60): - """Download an ISO""" - # Ensuring ISO is successfully downloaded - while True: - time.sleep(interval) - - cmd = listIsos.listIsosCmd() - cmd.id = self.id - iso_response = apiclient.listIsos(cmd) - - if isinstance(iso_response, list): - response = iso_response[0] - # Again initialize timeout to avoid listISO failure - timeout = 5 - # Check whether download is in progress(for Ex:10% Downloaded) - # or ISO is 'Successfully Installed' - if response.status == 'Successfully Installed': - return - elif 'Downloaded' not in response.status and \ - 'Installing' not in response.status: - raise Exception( - "Error In Downloading ISO: ISO Status - %s" % - response.status) - - elif timeout == 0: - raise Exception("ISO download Timeout Exception") - else: - timeout = timeout - 1 - return - - @classmethod - def extract(cls, apiclient, id, mode, zoneid=None): - "Extract ISO " - - cmd = extractIso.extractIsoCmd() - cmd.id = id - cmd.mode = mode - cmd.zoneid = zoneid - - return apiclient.extractIso(cmd) - - def update(self, apiclient, **kwargs): - """Updates the ISO details""" - - cmd = updateIso.updateIsoCmd() - cmd.id = self.id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.updateIso(cmd)) - - @classmethod - def copy(cls, apiclient, id, sourcezoneid, destzoneid): - "Copy ISO from source Zone to Destination Zone" - - cmd = copyIso.copyIsoCmd() - cmd.id = id - cmd.sourcezoneid = sourcezoneid - cmd.destzoneid = destzoneid - - return apiclient.copyIso(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """Lists all available ISO files.""" - - cmd = listIsos.listIsosCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listIsos(cmd)) - - -class PublicIPAddress: - """Manage Public IP Addresses""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, accountid=None, zoneid=None, domainid=None, - services=None, networkid=None, projectid=None, vpcid=None, - isportable=False): - """Associate Public IP address""" - cmd = associateIpAddress.associateIpAddressCmd() - - if accountid: - cmd.account = accountid - elif services and "account" in services: - cmd.account = services["account"] - - if zoneid: - cmd.zoneid = zoneid - elif "zoneid" in services: - cmd.zoneid = services["zoneid"] - - if domainid: - cmd.domainid = domainid - elif services and "domainid" in services: - cmd.domainid = services["domainid"] - - if isportable: - cmd.isportable = isportable - - if networkid: - cmd.networkid = networkid - - if projectid: - cmd.projectid = projectid - - if vpcid: - cmd.vpcid = vpcid - return PublicIPAddress(apiclient.associateIpAddress(cmd).__dict__) - - def delete(self, apiclient): - """Dissociate Public IP address""" - cmd = disassociateIpAddress.disassociateIpAddressCmd() - cmd.id = self.ipaddress.id - apiclient.disassociateIpAddress(cmd) - return - - @classmethod - def list(cls, apiclient, **kwargs): - """List all Public IPs matching criteria""" - - cmd = listPublicIpAddresses.listPublicIpAddressesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listPublicIpAddresses(cmd)) - - -class NATRule: - """Manage port forwarding rule""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, virtual_machine, services, ipaddressid=None, - projectid=None, openfirewall=False, networkid=None, vpcid=None, - vmguestip=None): - """Create Port forwarding rule""" - cmd = createPortForwardingRule.createPortForwardingRuleCmd() - - if ipaddressid: - cmd.ipaddressid = ipaddressid - elif "ipaddressid" in services: - cmd.ipaddressid = services["ipaddressid"] - - cmd.privateport = services["privateport"] - cmd.publicport = services["publicport"] - if "privateendport" in services: - cmd.privateendport = services["privateendport"] - if "publicendport" in services: - cmd.publicendport = services["publicendport"] - cmd.protocol = services["protocol"] - cmd.virtualmachineid = virtual_machine.id - - if projectid: - cmd.projectid = projectid - - if openfirewall: - cmd.openfirewall = True - - if networkid: - cmd.networkid = networkid - - if vpcid: - cmd.vpcid = vpcid - - if vmguestip: - cmd.vmguestip = vmguestip - - return NATRule(apiclient.createPortForwardingRule(cmd).__dict__) - - def delete(self, apiclient): - """Delete port forwarding""" - cmd = deletePortForwardingRule.deletePortForwardingRuleCmd() - cmd.id = self.id - apiclient.deletePortForwardingRule(cmd) - return - - @classmethod - def list(cls, apiclient, **kwargs): - """List all NAT rules matching criteria""" - - cmd = listPortForwardingRules.listPortForwardingRulesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listPortForwardingRules(cmd)) - - -class StaticNATRule: - """Manage Static NAT rule""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, ipaddressid=None, - networkid=None, vpcid=None): - """Creates static ip forwarding rule""" - - cmd = createFirewallRule.createFirewallRuleCmd() - cmd.protocol = services["protocol"] - cmd.startport = services["startport"] - - if "endport" in services: - cmd.endport = services["endport"] - - if "cidrlist" in services: - cmd.cidrlist = services["cidrlist"] - - if ipaddressid: - cmd.ipaddressid = ipaddressid - elif "ipaddressid" in services: - cmd.ipaddressid = services["ipaddressid"] - - if networkid: - cmd.networkid = networkid - - if vpcid: - cmd.vpcid = vpcid - return StaticNATRule(apiclient.createFirewallRule(cmd).__dict__) - - @classmethod - def createIpForwardingRule(cls, apiclient, startport, endport, protocol, ipaddressid, openfirewall): - """Creates static ip forwarding rule""" - - cmd = createIpForwardingRule.createIpForwardingRuleCmd() - cmd.startport = startport - cmd.endport = endport - cmd.protocol = protocol - cmd.openfirewall = openfirewall - cmd.ipaddressid = ipaddressid - return StaticNATRule(apiclient.createIpForwardingRule(cmd).__dict__) - - def delete(self, apiclient): - """Delete IP forwarding rule""" - cmd = deleteIpForwardingRule.deleteIpForwardingRuleCmd() - cmd.id = self.id - apiclient.deleteIpForwardingRule(cmd) - return - - @classmethod - def list(cls, apiclient, **kwargs): - """List all IP forwarding rules matching criteria""" - - cmd = listIpForwardingRules.listIpForwardingRulesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listIpForwardingRules(cmd)) - - @classmethod - def enable(cls, apiclient, ipaddressid, virtualmachineid, networkid=None, - vmguestip=None): - """Enables Static NAT rule""" - - cmd = enableStaticNat.enableStaticNatCmd() - cmd.ipaddressid = ipaddressid - cmd.virtualmachineid = virtualmachineid - if networkid: - cmd.networkid = networkid - - if vmguestip: - cmd.vmguestip = vmguestip - apiclient.enableStaticNat(cmd) - return - - @classmethod - def disable(cls, apiclient, ipaddressid, virtualmachineid=None): - """Disables Static NAT rule""" - - cmd = disableStaticNat.disableStaticNatCmd() - cmd.ipaddressid = ipaddressid - apiclient.disableStaticNat(cmd) - return - - -class EgressFireWallRule: - - """Manage Egress Firewall rule""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, networkid, protocol, cidrlist=None, - startport=None, endport=None): - """Create Egress Firewall Rule""" - cmd = createEgressFirewallRule.createEgressFirewallRuleCmd() - cmd.networkid = networkid - cmd.protocol = protocol - if cidrlist: - cmd.cidrlist = cidrlist - if startport: - cmd.startport = startport - if endport: - cmd.endport = endport - - return EgressFireWallRule( - apiclient.createEgressFirewallRule(cmd).__dict__) - - def delete(self, apiclient): - """Delete Egress Firewall rule""" - cmd = deleteEgressFirewallRule.deleteEgressFirewallRuleCmd() - cmd.id = self.id - apiclient.deleteEgressFirewallRule(cmd) - return - - @classmethod - def list(cls, apiclient, **kwargs): - """List all Egress Firewall Rules matching criteria""" - - cmd = listEgressFirewallRules.listEgressFirewallRulesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listEgressFirewallRules(cmd)) - - -class FireWallRule: - - """Manage Firewall rule""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, ipaddressid, protocol, cidrlist=None, - startport=None, endport=None, projectid=None, vpcid=None): - """Create Firewall Rule""" - cmd = createFirewallRule.createFirewallRuleCmd() - cmd.ipaddressid = ipaddressid - cmd.protocol = protocol - if cidrlist: - cmd.cidrlist = cidrlist - if startport: - cmd.startport = startport - if endport: - cmd.endport = endport - - if projectid: - cmd.projectid = projectid - - if vpcid: - cmd.vpcid = vpcid - - return FireWallRule(apiclient.createFirewallRule(cmd).__dict__) - - def delete(self, apiclient): - """Delete Firewall rule""" - cmd = deleteFirewallRule.deleteFirewallRuleCmd() - cmd.id = self.id - apiclient.deleteFirewallRule(cmd) - return - - @classmethod - def list(cls, apiclient, **kwargs): - """List all Firewall Rules matching criteria""" - - cmd = listFirewallRules.listFirewallRulesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listFirewallRules(cmd)) - -class Autoscale: - - """Manage Auto scale""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def listCounters(cls, apiclient, **kwargs): - """Lists all available Counters.""" - - cmd = listCounters.listCountersCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.listCounters(cmd)) - - @classmethod - def createCondition(cls, apiclient, counterid, relationaloperator, threshold): - """creates condition.""" - - cmd = createCondition.createConditionCmd() - cmd.counterid = counterid - cmd.relationaloperator = relationaloperator - cmd.threshold = threshold - return(apiclient.createCondition(cmd)) - - @classmethod - def listConditions(cls, apiclient, **kwargs): - """Lists all available Conditions.""" - - cmd = listConditions.listConditionsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.listConditions(cmd)) - - @classmethod - def listAutoscalePolicies(cls, apiclient, **kwargs): - """Lists all available Autoscale Policies.""" - - cmd = listAutoScalePolicies.listAutoScalePoliciesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.listAutoScalePolicies(cmd)) - - @classmethod - def createAutoscalePolicy(cls, apiclient, action, conditionids, duration, quiettime=None): - """creates condition.""" - - cmd = createAutoScalePolicy.createAutoScalePolicyCmd() - cmd.action = action - cmd.conditionids = conditionids - cmd.duration = duration - if quiettime: - cmd.quiettime = quiettime - - return(apiclient.createAutoScalePolicy(cmd)) - - @classmethod - def updateAutoscalePolicy(cls, apiclient, id, **kwargs): - """Updates Autoscale Policy.""" - - cmd = updateAutoScalePolicy.updateAutoScalePolicyCmd() - cmd.id = id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.updateAutoScalePolicy(cmd)) - - @classmethod - def listAutoscaleVmPofiles(cls, apiclient, **kwargs): - """Lists all available AutoscaleVM Profiles.""" - - cmd = listAutoScaleVmProfiles.listAutoScaleVmProfilesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.listAutoScaleVmProfiles(cmd)) - - @classmethod - def createAutoscaleVmProfile(cls, apiclient, serviceofferingid, zoneid, templateid, - autoscaleuserid=None, destroyvmgraceperiod=None, counterparam=None): - """creates Autoscale VM Profile.""" - - cmd = createAutoScaleVmProfile.createAutoScaleVmProfileCmd() - cmd.serviceofferingid = serviceofferingid - cmd.zoneid = zoneid - cmd.templateid = templateid - if autoscaleuserid: - cmd.autoscaleuserid = autoscaleuserid - - if destroyvmgraceperiod: - cmd.destroyvmgraceperiod = destroyvmgraceperiod - - if counterparam: - for name, value in counterparam.items(): - cmd.counterparam.append({ - 'name': name, - 'value': value - }) - - return(apiclient.createAutoScaleVmProfile(cmd)) - - @classmethod - def updateAutoscaleVMProfile(cls, apiclient, id, **kwargs): - """Updates Autoscale Policy.""" - - cmd = updateAutoScaleVmProfile.updateAutoScaleVmProfileCmd() - cmd.id = id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.updateAutoScaleVmProfile(cmd)) - - @classmethod - def createAutoscaleVmGroup(cls, apiclient, lbruleid, minmembers, maxmembers, - scaledownpolicyids, scaleuppolicyids, vmprofileid, interval=None): - """creates Autoscale VM Group.""" - - cmd = createAutoScaleVmGroup.createAutoScaleVmGroupCmd() - cmd.lbruleid = lbruleid - cmd.minmembers = minmembers - cmd.maxmembers = maxmembers - cmd.scaledownpolicyids = scaledownpolicyids - cmd.scaleuppolicyids = scaleuppolicyids - cmd.vmprofileid = vmprofileid - if interval: - cmd.interval = interval - - return(apiclient.createAutoScaleVmGroup(cmd)) - - @classmethod - def listAutoscaleVmGroup(cls, apiclient, **kwargs): - """Lists all available AutoscaleVM Group.""" - - cmd = listAutoScaleVmGroups.listAutoScaleVmGroupsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.listAutoScaleVmGroups(cmd)) - - @classmethod - def enableAutoscaleVmGroup(cls, apiclient, id, **kwargs): - """Enables AutoscaleVM Group.""" - - cmd = enableAutoScaleVmGroup.enableAutoScaleVmGroupCmd() - cmd.id = id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.enableAutoScaleVmGroup(cmd)) - - @classmethod - def disableAutoscaleVmGroup(cls, apiclient, id, **kwargs): - """Disables AutoscaleVM Group.""" - - cmd = disableAutoScaleVmGroup.disableAutoScaleVmGroupCmd() - cmd.id = id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.disableAutoScaleVmGroup(cmd)) - - @classmethod - def updateAutoscaleVMGroup(cls, apiclient, id, **kwargs): - """Updates Autoscale VM Group.""" - - cmd = updateAutoScaleVmGroup.updateAutoScaleVmGroupCmd() - cmd.id = id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.updateAutoScaleVmGroup(cmd)) - - -class ServiceOffering: - - """Manage service offerings cycle""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, domainid=None, **kwargs): - """Create Service offering""" - cmd = createServiceOffering.createServiceOfferingCmd() - cmd.cpunumber = services["cpunumber"] - cmd.cpuspeed = services["cpuspeed"] - cmd.displaytext = services["displaytext"] - cmd.memory = services["memory"] - cmd.name = services["name"] - if "storagetype" in services: - cmd.storagetype = services["storagetype"] - - if "systemvmtype" in services: - cmd.systemvmtype = services['systemvmtype'] - - if "issystem" in services: - cmd.issystem = services['issystem'] - - if "tags" in services: - cmd.tags = services["tags"] - - if "hosttags" in services: - cmd.hosttags = services["hosttags"] - - if "deploymentplanner" in services: - cmd.deploymentplanner = services["deploymentplanner"] - - if "serviceofferingdetails" in services: - count = 1 - for i in services["serviceofferingdetails"]: - for key, value in i.items(): - setattr(cmd, "serviceofferingdetails[%d].key" % count, key) - setattr(cmd, "serviceofferingdetails[%d].value" % count, value) - count = count + 1 - - if "isvolatile" in services: - cmd.isvolatile = services["isvolatile"] - - if "miniops" in services: - cmd.miniops = services["miniops"] - - if "maxiops" in services: - cmd.maxiops = services["maxiops"] - - if "customizediops" in services: - cmd.customizediops = services["customizediops"] - - if "offerha" in services: - cmd.offerha = services["offerha"] - - # Service Offering private to that domain - if domainid: - cmd.domainid = domainid - - [setattr(cmd, k, v) for k, v in kwargs.items()] - return ServiceOffering(apiclient.createServiceOffering(cmd).__dict__) - - def delete(self, apiclient): - """Delete Service offering""" - cmd = deleteServiceOffering.deleteServiceOfferingCmd() - cmd.id = self.id - apiclient.deleteServiceOffering(cmd) - return - - @classmethod - def list(cls, apiclient, **kwargs): - """Lists all available service offerings.""" - - cmd = listServiceOfferings.listServiceOfferingsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listServiceOfferings(cmd)) - - -class DiskOffering: - """Manage disk offerings cycle""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, custom=False, domainid=None): - """Create Disk offering""" - cmd = createDiskOffering.createDiskOfferingCmd() - cmd.displaytext = services["displaytext"] - cmd.name = services["name"] - if custom: - cmd.customized = True - else: - cmd.disksize = services["disksize"] - - if domainid: - cmd.domainid = domainid - - if "storagetype" in services: - cmd.storagetype = services["storagetype"] - - if "customizediops" in services: - cmd.customizediops = services["customizediops"] - - if "disksize" in services: - cmd.disksize = services["disksize"] - - if "maxiops" in services: - cmd.maxiops = services["maxiops"] - - if "miniops" in services: - cmd.miniops = services["miniops"] - - if "tags" in services: - cmd.tags = services["tags"] - - if "provisioningtype" in services: - cmd.provisioningtype = services["provisioningtype"] - - return DiskOffering(apiclient.createDiskOffering(cmd).__dict__) - - def delete(self, apiclient): - """Delete Disk offering""" - cmd = deleteDiskOffering.deleteDiskOfferingCmd() - cmd.id = self.id - apiclient.deleteDiskOffering(cmd) - return - - @classmethod - def list(cls, apiclient, **kwargs): - """Lists all available disk offerings.""" - - cmd = listDiskOfferings.listDiskOfferingsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listDiskOfferings(cmd)) - - -class NetworkOffering: - """Manage network offerings cycle""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, **kwargs): - """Create network offering""" - - cmd = createNetworkOffering.createNetworkOfferingCmd() - cmd.displaytext = "-".join([services["displaytext"], random_gen()]) - cmd.name = "-".join([services["name"], random_gen()]) - cmd.guestiptype = services["guestiptype"] - cmd.supportedservices = '' - if "supportedservices" in services: - cmd.supportedservices = services["supportedservices"] - cmd.traffictype = services["traffictype"] - - if "useVpc" in services: - cmd.useVpc = services["useVpc"] - cmd.serviceproviderlist = [] - if "serviceProviderList" in services: - for service, provider in services["serviceProviderList"].items(): - cmd.serviceproviderlist.append({ - 'service': service, - 'provider': provider - }) - if "serviceCapabilityList" in services: - cmd.servicecapabilitylist = [] - for service, capability in services["serviceCapabilityList"].\ - items(): - for ctype, value in capability.items(): - cmd.servicecapabilitylist.append({ - 'service': service, - 'capabilitytype': ctype, - 'capabilityvalue': value - }) - if "specifyVlan" in services: - cmd.specifyVlan = services["specifyVlan"] - if "specifyIpRanges" in services: - cmd.specifyIpRanges = services["specifyIpRanges"] - if "ispersistent" in services: - cmd.ispersistent = services["ispersistent"] - if "egress_policy" in services: - cmd.egressdefaultpolicy = services["egress_policy"] - - cmd.availability = 'Optional' - - [setattr(cmd, k, v) for k, v in kwargs.items()] - - return NetworkOffering(apiclient.createNetworkOffering(cmd).__dict__) - - def delete(self, apiclient): - """Delete network offering""" - cmd = deleteNetworkOffering.deleteNetworkOfferingCmd() - cmd.id = self.id - apiclient.deleteNetworkOffering(cmd) - return - - def update(self, apiclient, **kwargs): - """Lists all available network offerings.""" - - cmd = updateNetworkOffering.updateNetworkOfferingCmd() - cmd.id = self.id - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.updateNetworkOffering(cmd)) - - @classmethod - def list(cls, apiclient, **kwargs): - """Lists all available network offerings.""" - - cmd = listNetworkOfferings.listNetworkOfferingsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listNetworkOfferings(cmd)) - - -class SnapshotPolicy: - """Manage snapshot policies""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, volumeid, services): - """Create Snapshot policy""" - cmd = createSnapshotPolicy.createSnapshotPolicyCmd() - cmd.intervaltype = services["intervaltype"] - cmd.maxsnaps = services["maxsnaps"] - cmd.schedule = services["schedule"] - cmd.timezone = services["timezone"] - cmd.volumeid = volumeid - return SnapshotPolicy(apiclient.createSnapshotPolicy(cmd).__dict__) - - def delete(self, apiclient): - """Delete Snapshot policy""" - cmd = deleteSnapshotPolicies.deleteSnapshotPoliciesCmd() - cmd.id = self.id - apiclient.deleteSnapshotPolicies(cmd) - return - - @classmethod - def list(cls, apiclient, **kwargs): - """Lists snapshot policies.""" - - cmd = listSnapshotPolicies.listSnapshotPoliciesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listSnapshotPolicies(cmd)) - -class Hypervisor: - """Manage Hypervisor""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def list(cls, apiclient, **kwargs): - """Lists hypervisors""" - - cmd = listHypervisors.listHypervisorsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listHypervisors(cmd)) - - -class LoadBalancerRule: - """Manage Load Balancer rule""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, ipaddressid=None, accountid=None, - networkid=None, vpcid=None, projectid=None, domainid=None): - """Create Load balancing Rule""" - - cmd = createLoadBalancerRule.createLoadBalancerRuleCmd() - - if ipaddressid: - cmd.publicipid = ipaddressid - elif "ipaddressid" in services: - cmd.publicipid = services["ipaddressid"] - - if accountid: - cmd.account = accountid - elif "account" in services: - cmd.account = services["account"] - - if domainid: - cmd.domainid = domainid - - if vpcid: - cmd.vpcid = vpcid - cmd.name = services["name"] - cmd.algorithm = services["alg"] - cmd.privateport = services["privateport"] - cmd.publicport = services["publicport"] - - if "openfirewall" in services: - cmd.openfirewall = services["openfirewall"] - - if projectid: - cmd.projectid = projectid - - if networkid: - cmd.networkid = networkid - return LoadBalancerRule(apiclient.createLoadBalancerRule(cmd).__dict__) - - def delete(self, apiclient): - """Delete load balancing rule""" - cmd = deleteLoadBalancerRule.deleteLoadBalancerRuleCmd() - cmd.id = self.id - apiclient.deleteLoadBalancerRule(cmd) - return - - def assign(self, apiclient, vms=None, vmidipmap=None): - """Assign virtual machines to load balancing rule""" - cmd = assignToLoadBalancerRule.assignToLoadBalancerRuleCmd() - cmd.id = self.id - if vmidipmap: - cmd.vmidipmap = vmidipmap - if vms: - cmd.virtualmachineids = [str(vm.id) for vm in vms] - apiclient.assignToLoadBalancerRule(cmd) - return - - def remove(self, apiclient, vms=None, vmidipmap=None): - """Remove virtual machines from load balancing rule""" - cmd = removeFromLoadBalancerRule.removeFromLoadBalancerRuleCmd() - cmd.id = self.id - if vms: - cmd.virtualmachineids = [str(vm.id) for vm in vms] - if vmidipmap: - cmd.vmidipmap = vmidipmap - apiclient.removeFromLoadBalancerRule(cmd) - return - - def update(self, apiclient, algorithm=None, - description=None, name=None, **kwargs): - """Updates the load balancing rule""" - cmd = updateLoadBalancerRule.updateLoadBalancerRuleCmd() - cmd.id = self.id - if algorithm: - cmd.algorithm = algorithm - if description: - cmd.description = description - if name: - cmd.name = name - - [setattr(cmd, k, v) for k, v in kwargs.items()] - return apiclient.updateLoadBalancerRule(cmd) - - def createSticky( - self, apiclient, methodname, name, description=None, param=None): - """Creates a sticky policy for the LB rule""" - - cmd = createLBStickinessPolicy.createLBStickinessPolicyCmd() - cmd.lbruleid = self.id - cmd.methodname = methodname - cmd.name = name - if description: - cmd.description = description - if param: - cmd.param = [] - for name, value in param.items(): - cmd.param.append({'name': name, 'value': value}) - return apiclient.createLBStickinessPolicy(cmd) - - def deleteSticky(self, apiclient, id): - """Deletes stickyness policy""" - - cmd = deleteLBStickinessPolicy.deleteLBStickinessPolicyCmd() - cmd.id = id - return apiclient.deleteLBStickinessPolicy(cmd) - - @classmethod - def listStickyPolicies(cls, apiclient, lbruleid, **kwargs): - """Lists stickiness policies for load balancing rule""" - - cmd = listLBStickinessPolicies.listLBStickinessPoliciesCmd() - cmd.lbruleid = lbruleid - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return apiclient.listLBStickinessPolicies(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """List all Load balancing rules matching criteria""" - - cmd = listLoadBalancerRules.listLoadBalancerRulesCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listLoadBalancerRules(cmd)) - - @classmethod - def listLoadBalancerRuleInstances(cls, apiclient, id, lbvmips=False, applied=None, **kwargs): - """Lists load balancing rule Instances""" - - cmd = listLoadBalancerRuleInstances.listLoadBalancerRuleInstancesCmd() - cmd.id = id - if applied: - cmd.applied = applied - cmd.lbvmips = lbvmips - - [setattr(cmd, k, v) for k, v in kwargs.items()] - return apiclient.listLoadBalancerRuleInstances(cmd) - - -class Cluster: - """Manage Cluster life cycle""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, zoneid=None, podid=None, hypervisor=None): - """Create Cluster""" - cmd = addCluster.addClusterCmd() - cmd.clustertype = services["clustertype"] - cmd.hypervisor = hypervisor - - if zoneid: - cmd.zoneid = zoneid - else: - cmd.zoneid = services["zoneid"] - - if podid: - cmd.podid = podid - else: - cmd.podid = services["podid"] - - if "username" in services: - cmd.username = services["username"] - if "password" in services: - cmd.password = services["password"] - if "url" in services: - cmd.url = services["url"] - if "clustername" in services: - cmd.clustername = services["clustername"] - - return Cluster(apiclient.addCluster(cmd)[0].__dict__) - - def delete(self, apiclient): - """Delete Cluster""" - cmd = deleteCluster.deleteClusterCmd() - cmd.id = self.id - apiclient.deleteCluster(cmd) - return - - @classmethod - def list(cls, apiclient, **kwargs): - """List all Clusters matching criteria""" - - cmd = listClusters.listClustersCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listClusters(cmd)) - - -class Host: - """Manage Host life cycle""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, cluster, services, zoneid=None, podid=None, hypervisor=None): - """ - 1. Creates the host based upon the information provided. - 2. Verifies the output of the adding host and its state post addition - Returns FAILED in case of an issue, else an instance of Host - """ - try: - cmd = addHost.addHostCmd() - cmd.hypervisor = hypervisor - cmd.url = services["url"] - cmd.clusterid = cluster.id - - if zoneid: - cmd.zoneid = zoneid - else: - cmd.zoneid = services["zoneid"] - - if podid: - cmd.podid = podid - else: - cmd.podid = services["podid"] - - if "clustertype" in services: - cmd.clustertype = services["clustertype"] - if "username" in services: - cmd.username = services["username"] - if "password" in services: - cmd.password = services["password"] - - ''' - Adds a Host, - If response is valid and host is up return - an instance of Host. - If response is invalid, returns FAILED. - If host state is not up, verify through listHosts call - till host status is up and return accordingly. Max 3 retries - ''' - host = apiclient.addHost(cmd) - ret = validateList(host) - if ret[0] == PASS: - if str(host[0].state).lower() == 'up': - return Host(host[0].__dict__) - retries = 3 - while retries: - lh_resp = apiclient.listHosts(host[0].id) - ret = validateList(lh_resp) - if (ret[0] == PASS) and \ - (str(ret[1].state).lower() == 'up'): - return Host(host[0].__dict__) - retries += -1 - return FAILED - except Exception as e: - print "Exception Occurred Under Host.create : %s" % \ - GetDetailExceptionInfo(e) - return FAILED - - def delete(self, apiclient): - """Delete Host""" - # Host must be in maintenance mode before deletion - cmd = prepareHostForMaintenance.prepareHostForMaintenanceCmd() - cmd.id = self.id - apiclient.prepareHostForMaintenance(cmd) - time.sleep(30) - - cmd = deleteHost.deleteHostCmd() - cmd.id = self.id - apiclient.deleteHost(cmd) - return - - def enableMaintenance(self, apiclient): - """enables maintenance mode Host""" - - cmd = prepareHostForMaintenance.prepareHostForMaintenanceCmd() - cmd.id = self.id - return apiclient.prepareHostForMaintenance(cmd) - - @classmethod - def enableMaintenance(cls, apiclient, id): - """enables maintenance mode Host""" - - cmd = prepareHostForMaintenance.prepareHostForMaintenanceCmd() - cmd.id = id - return apiclient.prepareHostForMaintenance(cmd) - - def cancelMaintenance(self, apiclient): - """Cancels maintenance mode Host""" - - cmd = cancelHostMaintenance.cancelHostMaintenanceCmd() - cmd.id = self.id - return apiclient.cancelHostMaintenance(cmd) - - @classmethod - def cancelMaintenance(cls, apiclient, id): - """Cancels maintenance mode Host""" - - cmd = cancelHostMaintenance.cancelHostMaintenanceCmd() - cmd.id = id - return apiclient.cancelHostMaintenance(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """List all Hosts matching criteria""" - - cmd = listHosts.listHostsCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.listHosts(cmd)) - - @classmethod - def listForMigration(cls, apiclient, **kwargs): - """List all Hosts for migration matching criteria""" - - cmd = findHostsForMigration.findHostsForMigrationCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - if 'account' in kwargs.keys() and 'domainid' in kwargs.keys(): - cmd.listall = True - return(apiclient.findHostsForMigration(cmd)) - - @classmethod - def update(cls, apiclient, **kwargs): - """Update host information""" - - cmd = updateHost.updateHostCmd() - [setattr(cmd, k, v) for k, v in kwargs.items()] - return(apiclient.updateHost(cmd)) - - -class StoragePool: - """Manage Storage pools (Primary Storage)""" - - def __init__(self, items): - self.__dict__.update(items) - - @classmethod - def create(cls, apiclient, services, scope=None, clusterid=None, - zoneid=None, podid=None, provider=None, tags=None, - capacityiops=None, capacitybytes=None, hypervisor=None): - """Create Storage pool (Primary Storage)""" - - cmd = createStoragePool.createStoragePoolCmd() - cmd.name = services["name"] - - if podid: - cmd.podid = podid - elif "podid" in services: - cmd.podid = services["podid"] - - cmd.url = services["url"] - if clusterid: - cmd.clusterid = clusterid - elif "clusterid" in services: - cmd.clusterid = services["clusterid"] - - if zoneid: - cmd.zoneid = zoneid - else: - cmd.zoneid = services["zoneid"] - - if scope: - cmd.scope = scope - elif "scope" in services: - cmd.scope = services["scope"] - - if provider: - cmd.provider = provider - elif "provider" in services: - cmd.provider = services["provider"] - - if tags: - cmd.tags = tags - elif "tags" in services: - cmd.tags = services["tags"] - - if capacityiops: - cmd.capacityiops = capacityiops - elif "capacityiops" in services: - cmd.capacityiops = services["capacityiops"] - - if capacitybytes: - cmd.capacitybytes = capacitybytes - elif "capacitybytes" in services: - cmd.capacitybytes = services["capacitybytes"] - - if hypervisor: - cmd.hypervisor = hypervisor - elif "hypervisor" in services: - cmd.hypervisor = services["hypervisor"] - - return StoragePool(apiclient.createStoragePool(cmd).__dict__) - - def delete(self, apiclient): - """Delete Storage pool (Primary Storage)""" - - # Storage pool must be in maintenance mode before deletion - cmd = enableStorageMaintenance.enableStorageMaintenanceCmd() - cmd.id = self.id - apiclient.enableStorageMaintenance(cmd) - time.sleep(30) - cmd = deleteStoragePool.deleteStoragePoolCmd() - cmd.id = self.id - apiclient.deleteStoragePool(cmd) - return - - def enableMaintenance(self, apiclient): - """enables maintenance mode Storage pool""" - - cmd = enableStorageMaintenance.enableStorageMaintenanceCmd() - cmd.id = self.id - return apiclient.enableStorageMaintenance(cmd) - - @classmethod - def list(cls, apiclient, **kwargs): - """List all storage pools matching criteria""" - - cmd = listStoragePools.listS
<TRUNCATED> http://git-wip-us.apache.org/repos/asf/cloudstack/blob/d002c52a/tools/marvin/marvin/lib/cloudstack/__init__.py ---------------------------------------------------------------------- diff --git a/tools/marvin/marvin/lib/cloudstack/__init__.py b/tools/marvin/marvin/lib/cloudstack/__init__.py new file mode 100644 index 0000000..0871bc1 --- /dev/null +++ b/tools/marvin/marvin/lib/cloudstack/__init__.py @@ -0,0 +1 @@ +__author__ = 'edison'
