cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bfede...@apache.org
Subject [03/76] [abbrv] CLOUSTACK-5099: Utils.py-has-wrong-reference, cleaned it. As well added Uniform naming convention Signed-off-by: SrikanteswaraRao Talluri <talluri@apache.org>
Date Fri, 08 Nov 2013 18:08:19 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/ec00a6fb/tools/marvin/build/lib/marvin/integration/lib/base.py
----------------------------------------------------------------------
diff --git a/tools/marvin/build/lib/marvin/integration/lib/base.py b/tools/marvin/build/lib/marvin/integration/lib/base.py
new file mode 100644
index 0000000..4f15137
--- /dev/null
+++ b/tools/marvin/build/lib/marvin/integration/lib/base.py
@@ -0,0 +1,3593 @@
+# 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 utils import is_server_ssh_ready, random_gen
+from marvin.cloudstackAPI import *
+# 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()]
+        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"]
+        cmd.username = "-".join([services["username"], random_gen(id=apiclient.id)])
+
+        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()]
+        return(apiclient.listAccounts(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()]
+        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"""
+
+    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,
+                securitygroupname="basic_sec_grp"
+            )
+
+            if not isinstance(list_security_groups, list):
+                basic_mode_security_group = SecurityGroup.create(
+                    apiclient,
+                    {"name": "basic_sec_grp"}
+                )
+                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):
+        """
+        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
+        )
+        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:
+            EgressFireWallRule.create(
+                apiclient=apiclient,
+                networkid=virtual_machine.nic[0].networkid,
+                protocol='All',
+                cidrlist='0.0.0.0/0'
+            )
+        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'):
+        """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"]
+        cmd.hypervisor = apiclient.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"])
+
+        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 == 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)
+        elif mode.lower() == 'basic':
+            if virtual_machine.publicip is not None:
+                vm_ssh_ip = virtual_machine.publicip #EIP/ELB (netscaler) enabled zone
+            else:
+                vm_ssh_ip = virtual_machine.nic[0].ipaddress #regular basic zone with security group
+            virtual_machine.ssh_ip = vm_ssh_ip
+            virtual_machine.public_ip = vm_ssh_ip
+
+        return VirtualMachine(virtual_machine.__dict__, services)
+
+    def start(self, apiclient):
+        """Start the instance"""
+        cmd = startVirtualMachine.startVirtualMachineCmd()
+        cmd.id = self.id
+        apiclient.startVirtualMachine(cmd)
+
+    def stop(self, apiclient):
+        """Stop the instance"""
+        cmd = stopVirtualMachine.stopVirtualMachineCmd()
+        cmd.id = self.id
+        apiclient.stopVirtualMachine(cmd)
+
+    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 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 != 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 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):
+        """Destroy an Instance"""
+        cmd = destroyVirtualMachine.destroyVirtualMachineCmd()
+        cmd.id = self.id
+        apiclient.destroyVirtualMachine(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):
+        """Add a NIC to a VM"""
+        cmd = addNicToVirtualMachine.addNicToVirtualMachineCmd()
+        cmd.virtualmachineid = self.id
+        cmd.networkid = networkId
+        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.id = self.id
+        return apiclient.detachIso(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()]
+        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)
+
+
+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()]
+        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=5, 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 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
+    """
+    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()]
+        return(apiclient.listSnapshots(cmd))
+
+
+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):
+        """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"]
+        cmd.hypervisor = apiclient.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
+
+        # 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))
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """List all templates matching criteria"""
+
+        cmd = listTemplates.listTemplatesCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        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 list(cls, apiclient, **kwargs):
+        """Lists all available ISO files."""
+
+        cmd = listIsos.listIsosCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        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 "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 "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()]
+        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):
+        """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
+        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()]
+        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__)
+
+    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()]
+        return(apiclient.listIpForwardingRules(cmd))
+
+    @classmethod
+    def enable(cls, apiclient, ipaddressid, virtualmachineid, networkid=None):
+        """Enables Static NAT rule"""
+
+        cmd = enableStaticNat.enableStaticNatCmd()
+        cmd.ipaddressid = ipaddressid
+        cmd.virtualmachineid = virtualmachineid
+        if networkid:
+            cmd.networkid = networkid
+        apiclient.enableStaticNat(cmd)
+        return
+
+    @classmethod
+    def disable(cls, apiclient, ipaddressid, virtualmachineid):
+        """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()]
+        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()]
+        return(apiclient.listFirewallRules(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 "deploymentplanner" in services:
+            cmd.deploymentplanner = services["deploymentplanner"]
+
+        # 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()]
+        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"]
+
+        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()]
+        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()]
+        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()]
+        return(apiclient.listSnapshotPolicies(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):
+        """Assign virtual machines to load balancing rule"""
+        cmd = assignToLoadBalancerRule.assignToLoadBalancerRuleCmd()
+        cmd.id = self.id
+        cmd.virtualmachineids = [str(vm.id) for vm in vms]
+        apiclient.assignToLoadBalancerRule(cmd)
+        return
+
+    def remove(self, apiclient, vms):
+        """Remove virtual machines from load balancing rule"""
+        cmd = removeFromLoadBalancerRule.removeFromLoadBalancerRuleCmd()
+        cmd.id = self.id
+        cmd.virtualmachineids = [str(vm.id) for vm in vms]
+        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()]
+        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()]
+        return(apiclient.listLoadBalancerRules(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):
+        """Create Cluster"""
+        cmd = addCluster.addClusterCmd()
+        cmd.clustertype = services["clustertype"]
+        cmd.hypervisor = apiclient.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()]
+        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):
+        """Create Host in cluster"""
+
+        cmd = addHost.addHostCmd()
+        cmd.hypervisor = apiclient.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"]
+
+        # Add host
+        host = apiclient.addHost(cmd)
+
+        if isinstance(host, list):
+            return Host(host[0].__dict__)
+
+    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()]
+        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()]
+        return(apiclient.findHostsForMigration(cmd))
+
+
+class StoragePool:
+    """Manage Storage pools (Primary Storage)"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services, clusterid=None,
+                                        zoneid=None, podid=None):
+        """Create Storage pool (Primary Storage)"""
+
+        cmd = createStoragePool.createStoragePoolCmd()
+        cmd.name = services["name"]
+
+        if podid:
+            cmd.podid = podid
+        else:
+            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"]
+
+        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.listStoragePoolsCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listStoragePools(cmd))
+
+    @classmethod
+    def listForMigration(cls, apiclient, **kwargs):
+        """List all storage pools for migration matching criteria"""
+
+        cmd = findStoragePoolsForMigration.findStoragePoolsForMigrationCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.findStoragePoolsForMigration(cmd))
+
+class Network:
+    """Manage Network pools"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services, accountid=None, domainid=None,
+               networkofferingid=None, projectid=None,
+               subdomainaccess=None, zoneid=None,
+               gateway=None, netmask=None, vpcid=None, aclid=None):
+        """Create Network for account"""
+        cmd = createNetwork.createNetworkCmd()
+        cmd.name = services["name"]
+        cmd.displaytext = services["displaytext"]
+
+        if networkofferingid:
+            cmd.networkofferingid = networkofferingid
+        elif "networkoffering" in services:
+            cmd.networkofferingid = services["networkoffering"]
+
+        if zoneid:
+            cmd.zoneid = zoneid
+        elif "zoneid" in services:
+            cmd.zoneid = services["zoneid"]
+
+        if subdomainaccess is not None:
+            cmd.subdomainaccess = subdomainaccess
+
+        if gateway:
+            cmd.gateway = gateway
+        elif "gateway" in services:
+            cmd.gateway = services["gateway"]
+        if netmask:
+            cmd.netmask = netmask
+        elif "netmask" in services:
+            cmd.netmask = services["netmask"]
+        if "startip" in services:
+            cmd.startip = services["startip"]
+        if "endip" in services:
+            cmd.endip = services["endip"]
+        if "vlan" in services:
+            cmd.vlan = services["vlan"]
+        if "acltype" in services:
+            cmd.acltype = services["acltype"]
+
+        if accountid:
+            cmd.account = accountid
+        if domainid:
+            cmd.domainid = domainid
+        if projectid:
+            cmd.projectid = projectid
+        if vpcid:
+            cmd.vpcid = vpcid
+        if aclid:
+            cmd.aclid = aclid
+        return Network(apiclient.createNetwork(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete Account"""
+
+        cmd = deleteNetwork.deleteNetworkCmd()
+        cmd.id = self.id
+        apiclient.deleteNetwork(cmd)
+
+    def update(self, apiclient, **kwargs):
+        """Updates network with parameters passed"""
+
+        cmd = updateNetwork.updateNetworkCmd()
+        cmd.id = self.id
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.updateNetwork(cmd))
+
+    def restart(self, apiclient, cleanup=None):
+        """Restarts the network"""
+
+        cmd = restartNetwork.restartNetworkCmd()
+        cmd.id = self.id
+        if cleanup:
+            cmd.cleanup = cleanup
+        return(apiclient.restartNetwork(cmd))
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """List all Networks matching criteria"""
+
+        cmd = listNetworks.listNetworksCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listNetworks(cmd))
+
+
+class NetworkACL:
+    """Manage Network ACL lifecycle"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services, networkid=None, protocol=None,
+               number=None, aclid=None, action='Allow', traffictype=None, cidrlist=[]):
+        """Create network ACL rules(Ingress/Egress)"""
+
+        cmd = createNetworkACL.createNetworkACLCmd()
+        if "networkid" in services:
+            cmd.networkid = services["networkid"]
+        elif networkid:
+            cmd.networkid = networkid
+
+        if "protocol" in services:
+            cmd.protocol = services["protocol"]
+            if services["protocol"] == 'ICMP':
+                cmd.icmptype = -1
+                cmd.icmpcode = -1
+        elif protocol:
+            cmd.protocol = protocol
+
+        if "startport" in services:
+            cmd.startport = services["startport"]
+        if "endport" in services:
+            cmd.endport = services["endport"]
+
+        if "cidrlist" in services:
+            cmd.cidrlist = services["cidrlist"]
+        elif cidrlist:
+            cmd.cidrlist = cidrlist
+
+        if "traffictype" in services:
+            cmd.traffictype = services["traffictype"]
+        elif traffictype:
+            cmd.traffictype = traffictype
+
+        if "action" in services:
+            cmd.action = services["action"]
+        elif action:
+            cmd.action = action
+
+        if "number" in services:
+            cmd.number = services["number"]
+        elif number:
+            cmd.number = number
+
+        if "aclid" in services:
+            cmd.aclid = services["aclid"]
+        elif aclid:
+            cmd.aclid = aclid
+
+        # Defaulted to Ingress
+        return NetworkACL(apiclient.createNetworkACL(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete network acl"""
+
+        cmd = deleteNetworkACL.deleteNetworkACLCmd()
+        cmd.id = self.id
+        return apiclient.deleteNetworkACL(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """List Network ACLs"""
+
+        cmd = listNetworkACLs.listNetworkACLsCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listNetworkACLs(cmd))
+
+
+class NetworkACLList:
+    """Manage Network ACL lists lifecycle"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services, name=None, description=None, vpcid=None):
+        """Create network ACL container list"""
+
+        cmd = createNetworkACLList.createNetworkACLListCmd()
+        if "name" in services:
+            cmd.name = services["name"]
+        elif name:
+            cmd.name = name
+
+        if "description" in services:
+            cmd.description = services["description"]
+        elif description:
+            cmd.description = description
+
+        if "vpcid" in services:
+            cmd.vpcid = services["vpcid"]
+        elif vpcid:
+            cmd.vpcid = vpcid
+
+        return NetworkACLList(apiclient.createNetworkACLList(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete network acl list"""
+
+        cmd = deleteNetworkACLList.deleteNetworkACLListCmd()
+        cmd.id = self.id
+        return apiclient.deleteNetworkACLList(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """List Network ACL lists"""
+
+        cmd = listNetworkACLLists.listNetworkACLListsCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listNetworkACLLists(cmd))
+
+
+class Vpn:
+    """Manage VPN life cycle"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, publicipid, account=None, domainid=None,
+                        projectid=None, networkid=None, vpcid=None):
+        """Create VPN for Public IP address"""
+        cmd = createRemoteAccessVpn.createRemoteAccessVpnCmd()
+        cmd.publicipid = publicipid
+        if account:
+            cmd.account = account
+        if domainid:
+            cmd.domainid = domainid
+        if projectid:
+            cmd.projectid = projectid
+        if networkid:
+            cmd.networkid = networkid
+        if vpcid:
+            cmd.vpcid = vpcid
+        return Vpn(apiclient.createRemoteAccessVpn(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete remote VPN access"""
+
+        cmd = deleteRemoteAccessVpn.deleteRemoteAccessVpnCmd()
+        cmd.publicipid = self.publicipid
+        apiclient.deleteRemoteAccessVpn(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """List all VPN matching criteria"""
+
+        cmd = listRemoteAccessVpns.listRemoteAccessVpnsCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listRemoteAccessVpns(cmd))
+
+
+class VpnUser:
+    """Manage VPN user"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, username, password, account=None, domainid=None,
+               projectid=None, rand_name=True):
+        """Create VPN user"""
+        cmd = addVpnUser.addVpnUserCmd()
+        cmd.username = "-".join([username,
+                                 random_gen()]) if rand_name else username
+        cmd.password = password
+
+        if account:
+            cmd.account = account
+        if domainid:
+            cmd.domainid = domainid
+        if projectid:
+            cmd.projectid = projectid
+        return VpnUser(apiclient.addVpnUser(cmd).__dict__)
+
+    def delete(self, apiclient, projectid=None):
+        """Remove VPN user"""
+
+        cmd = removeVpnUser.removeVpnUserCmd()
+        cmd.username = self.username
+        if projectid:
+            cmd.projectid = projectid
+        else:
+            cmd.account = self.account
+            cmd.domainid = self.domainid
+        apiclient.removeVpnUser(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """List all VPN Users matching criteria"""
+
+        cmd = listVpnUsers.listVpnUsersCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listVpnUsers(cmd))
+
+
+class Zone:
+    """Manage Zone"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services, domainid=None):
+        """Create zone"""
+        cmd = createZone.createZoneCmd()
+        cmd.dns1 = services["dns1"]
+        cmd.internaldns1 = services["internaldns1"]
+        cmd.name = services["name"]
+        cmd.networktype = services["networktype"]
+
+        if "dns2" in services:
+            cmd.dns2 = services["dns2"]
+        if "internaldns2" in services:
+            cmd.internaldns2 = services["internaldns2"]
+        if domainid:
+            cmd.domainid = domainid
+
+        return Zone(apiclient.createZone(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete Zone"""
+
+        cmd = deleteZone.deleteZoneCmd()
+        cmd.id = self.id
+        apiclient.deleteZone(cmd)
+
+    def update(self, apiclient, **kwargs):
+        """Update the zone"""
+
+        cmd = updateZone.updateZoneCmd()
+        cmd.id = self.id
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return apiclient.updateZone(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """List all Zones matching criteria"""
+
+        cmd = listZones.listZonesCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listZones(cmd))
+
+
+class Pod:
+    """Manage Pod"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services):
+        """Create Pod"""
+        cmd = createPod.createPodCmd()
+        cmd.gateway = services["gateway"]
+        cmd.netmask = services["netmask"]
+        cmd.name = services["name"]
+        cmd.startip = services["startip"]
+        cmd.endip = services["endip"]
+        cmd.zoneid = services["zoneid"]
+
+        return Pod(apiclient.createPod(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete Pod"""
+
+        cmd = deletePod.deletePodCmd()
+        cmd.id = self.id
+        apiclient.deletePod(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        "Returns a default pod for specified zone"
+
+        cmd = listPods.listPodsCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return apiclient.listPods(cmd)
+
+
+class PublicIpRange:
+    """Manage VlanIpRange"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services):
+        """Create VlanIpRange"""
+
+        cmd = createVlanIpRange.createVlanIpRangeCmd()
+        cmd.gateway = services["gateway"]
+        cmd.netmask = services["netmask"]
+        cmd.forvirtualnetwork = services["forvirtualnetwork"]
+        cmd.startip = services["startip"]
+        cmd.endip = services["endip"]
+        cmd.zoneid = services["zoneid"]
+        cmd.podid = services["podid"]
+        cmd.vlan = services["vlan"]
+
+        return PublicIpRange(apiclient.createVlanIpRange(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete VlanIpRange"""
+
+        cmd = deleteVlanIpRange.deleteVlanIpRangeCmd()
+        cmd.id = self.vlan.id
+        apiclient.deleteVlanIpRange(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """Lists all VLAN IP ranges."""
+
+        cmd = listVlanIpRanges.listVlanIpRangesCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listVlanIpRanges(cmd))
+
+    @classmethod
+    def dedicate(cls, apiclient, id, account=None, domainid=None, projectid=None):
+        """Dedicate VLAN IP range"""
+
+        cmd = dedicatePublicIpRange.dedicatePublicIpRangeCmd()
+        cmd.id = id
+        cmd.account = account
+        cmd.domainid = domainid
+        cmd.projectid = projectid
+        return PublicIpRange(apiclient.dedicatePublicIpRange(cmd).__dict__)
+
+    def release(self, apiclient):
+        """Release VLAN IP range"""
+
+        cmd = releasePublicIpRange.releasePublicIpRangeCmd()
+        cmd.id = self.vlan.id
+        return apiclient.releasePublicIpRange(cmd)
+
+
+class PortablePublicIpRange:
+    """Manage portable public Ip Range"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services):
+        """Create portable public Ip Range"""
+
+        cmd = createPortableIpRange.createPortableIpRangeCmd()
+        cmd.gateway = services["gateway"]
+        cmd.netmask = services["netmask"]
+        cmd.startip = services["startip"]
+        cmd.endip = services["endip"]
+        cmd.regionid = services["regionid"]
+
+        if "vlan" in services:
+            cmd.vlan = services["vlan"]
+
+        return PortablePublicIpRange(apiclient.createPortableIpRange(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete portable IpRange"""
+
+        cmd = deletePortableIpRange.deletePortableIpRangeCmd()
+        cmd.id = self.id
+        apiclient.deletePortableIpRange(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """Lists all portable public IP ranges."""
+
+        cmd = listPortableIpRanges.listPortableIpRangesCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listPortableIpRanges(cmd))
+
+class SecondaryStagingStore:
+    """Manage Staging Store"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, url, provider, services=None):
+        """Create Staging Storage"""
+        cmd = createSecondaryStagingStore.createSecondaryStagingStoreCmd()
+        cmd.url = url
+        cmd.provider = provider
+        if services:
+            if "zoneid" in services:
+                cmd.zoneid = services["zoneid"]
+            if "details" in services:
+                cmd.details = services["details"]
+            if "scope" in services:
+                cmd.scope = services["scope"]
+
+        return SecondaryStagingStore(apiclient.createSecondaryStagingStore(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete Staging Storage"""
+        cmd = deleteSecondaryStagingStore.deleteSecondaryStagingStoreCmd()
+        cmd.id = self.id
+        apiclient.deleteSecondaryStagingStore(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        cmd = listSecondaryStagingStores.listSecondaryStagingStoresCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listSecondaryStagingStores(cmd))
+
+
+class ImageStore:
+    """Manage image stores"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, url, provider, services=None):
+        """Add Image Store"""
+        cmd = addImageStore.addImageStoreCmd()
+        cmd.url = url
+        cmd.provider = provider
+        if services:
+            if "zoneid" in services:
+                cmd.zoneid = services["zoneid"]
+            if "details" in services:
+                cmd.details = services["details"]
+            if "scope" in services:
+                cmd.scope = services["scope"]
+
+        return ImageStore(apiclient.addImageStore(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete Image Store"""
+        cmd = deleteImageStore.deleteImageStoreCmd()
+        cmd.id = self.id
+        apiclient.deleteImageStore(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        cmd = listImageStores.listImageStoresCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listImageStores(cmd))
+
+
+class PhysicalNetwork:
+    """Manage physical network storage"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services, zoneid, domainid=None):
+        """Create physical network"""
+        cmd = createPhysicalNetwork.createPhysicalNetworkCmd()
+
+        cmd.name = services["name"]
+        cmd.zoneid = zoneid
+        if domainid:
+            cmd.domainid = domainid
+        return PhysicalNetwork(apiclient.createPhysicalNetwork(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete Physical Network"""
+
+        cmd = deletePhysicalNetwork.deletePhysicalNetworkCmd()
+        cmd.id = self.id
+        apiclient.deletePhysicalNetwork(cmd)
+
+    def update(self, apiclient, **kwargs):
+        """Update Physical network state"""
+
+        cmd = updatePhysicalNetwork.updatePhysicalNetworkCmd()
+        cmd.id = self.id
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return apiclient.updatePhysicalNetwork(cmd)
+
+    def addTrafficType(self, apiclient, type):
+        """Add Traffic type to Physical network"""
+
+        cmd = addTrafficType.addTrafficTypeCmd()
+        cmd.physicalnetworkid = self.id
+        cmd.traffictype = type
+        return apiclient.addTrafficType(cmd)
+
+    @classmethod
+    def dedicate(cls, apiclient, vlanrange, physicalnetworkid, account=None, domainid=None, projectid=None):
+        """Dedicate guest vlan range"""
+
+        cmd = dedicateGuestVlanRange.dedicateGuestVlanRangeCmd()
+        cmd.vlanrange = vlanrange
+        cmd.physicalnetworkid = physicalnetworkid
+        cmd.account = account
+        cmd.domainid = domainid
+        cmd.projectid = projectid
+        return PhysicalNetwork(apiclient.dedicateGuestVlanRange(cmd).__dict__)
+
+    def release(self, apiclient):
+        """Release guest vlan range"""
+
+        cmd = releaseDedicatedGuestVlanRange.releaseDedicatedGuestVlanRangeCmd()
+        cmd.id = self.id
+        return apiclient.releaseDedicatedGuestVlanRange(cmd)
+
+    @classmethod
+    def listDedicated(cls, apiclient, **kwargs):
+        """Lists all dedicated guest vlan ranges"""
+
+        cmd = listDedicatedGuestVlanRanges.listDedicatedGuestVlanRangesCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return apiclient.listDedicatedGuestVlanRanges(cmd)
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """Lists all physical networks"""
+
+        cmd = listPhysicalNetworks.listPhysicalNetworksCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return map(lambda pn : PhysicalNetwork(pn.__dict__), apiclient.listPhysicalNetworks(cmd))
+
+
+class SecurityGroup:
+    """Manage Security Groups"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def create(cls, apiclient, services, account=None, domainid=None,
+               description=None, projectid=None):
+        """Create security group"""
+        cmd = createSecurityGroup.createSecurityGroupCmd()
+
+        cmd.name = services["name"]
+        if account:
+            cmd.account = account
+        if domainid:
+            cmd.domainid = domainid
+        if description:
+            cmd.description = description
+        if projectid:
+            cmd.projectid = projectid
+
+        return SecurityGroup(apiclient.createSecurityGroup(cmd).__dict__)
+
+    def delete(self, apiclient):
+        """Delete Security Group"""
+
+        cmd = deleteSecurityGroup.deleteSecurityGroupCmd()
+        cmd.id = self.id
+        apiclient.deleteSecurityGroup(cmd)
+
+    def authorize(self, apiclient, services,
+                  account=None, domainid=None, projectid=None):
+        """Authorize Ingress Rule"""
+
+        cmd = authorizeSecurityGroupIngress.authorizeSecurityGroupIngressCmd()
+
+        if domainid:
+            cmd.domainid = domainid
+        if account:
+            cmd.account = account
+
+        if projectid:
+            cmd.projectid = projectid
+        cmd.securitygroupid = self.id
+        cmd.protocol = services["protocol"]
+
+        if services["protocol"] == 'ICMP':
+            cmd.icmptype = -1
+            cmd.icmpcode = -1
+        else:
+            cmd.startport = services["startport"]
+            cmd.endport = services["endport"]
+
+        cmd.cidrlist = services["cidrlist"]
+        return (apiclient.authorizeSecurityGroupIngress(cmd).__dict__)
+
+    def revoke(self, apiclient, id):
+        """Revoke ingress rule"""
+
+        cmd = revokeSecurityGroupIngress.revokeSecurityGroupIngressCmd()
+        cmd.id = id
+        return apiclient.revokeSecurityGroupIngress(cmd)
+
+    def authorizeEgress(self, apiclient, services, account=None, domainid=None,
+                        projectid=None, user_secgrp_list={}):
+        """Authorize Egress Rule"""
+
+        cmd = authorizeSecurityGroupEgress.authorizeSecurityGroupEgressCmd()
+
+        if domainid:
+            cmd.domainid = domainid
+        if account:
+            cmd.account = account
+
+        if projectid:
+            cmd.projectid = projectid
+        cmd.securitygroupid = self.id
+        cmd.protocol = services["protocol"]
+
+        if services["protocol"] == 'ICMP':
+            cmd.icmptype = -1
+            cmd.icmpcode = -1
+        else:
+            cmd.startport = services["startport"]
+            cmd.endport = services["endport"]
+
+        cmd.cidrlist = services["cidrlist"]
+
+        cmd.usersecuritygrouplist = []
+        for account, group in user_secgrp

<TRUNCATED>

Mime
View raw message