Пример #1
0
def list_events(apiclient, **kwargs):
    """Lists events"""

    cmd = listEvents.listEventsCmd()
    [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.listEvents(cmd)
Пример #2
0
def list_events(apiclient, **kwargs):
    """Lists events"""

    cmd = listEvents.listEventsCmd()
    [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.listEvents(cmd))
Пример #3
0
    def test_01_events_resource(self):
        """Test Events resources while doing some operation on VM, volume, template, account, etc

        # Validate the following
        # 1. Note start time
        # 2. Deploy VM for a new account
        # 3. Check resource id and resource type of all concerned events during the period
        """
        now = datetime.now()  # current date and time
        start_time = now.strftime("%Y-%m-%d %H:%M:%S")

        template = get_suitable_test_template(self.apiclient, self.zone.id,
                                              self.services["ostype"],
                                              self.hypervisor)
        if template == FAILED:
            self.fail(
                "get_suitable_test_template() failed to return template with description %s"
                % self.services["ostype"])

        self.disk_offering = DiskOffering.create(
            self.apiclient, self.services["disk_offering"])
        self.cleanup.append(self.disk_offering)
        self.service_offering = ServiceOffering.create(
            self.apiclient, self.services["service_offerings"]["tiny"])
        self.cleanup.append(self.service_offering)
        self.network_offering = NetworkOffering.create(
            self.apiclient,
            self.services["network_offering"],
        )
        self.network_offering.update(self.apiclient, state='Enabled')
        self.services["network"]["networkoffering"] = self.network_offering.id
        self.cleanup.append(self.network_offering)
        self.services["zoneid"] = self.zone.id
        self.services["template"] = template.id
        self.services["network"]["zoneid"] = self.zone.id

        domain1 = Domain.create(self.apiclient,
                                self.services["domain"],
                                parentdomainid=self.domain.id)
        self.services["domainid"] = domain1.id

        account = Account.create(self.apiclient,
                                 self.services["account"],
                                 domainid=domain1.id)

        account_network = Network.create(self.apiclient,
                                         self.services["network"],
                                         account.name, account.domainid)
        virtual_machine = VirtualMachine.create(
            self.apiclient,
            self.services,
            accountid=account.name,
            domainid=account.domainid,
            networkids=account_network.id,
            serviceofferingid=self.service_offering.id)
        volume = Volume.create(self.apiclient,
                               self.services,
                               zoneid=self.zone.id,
                               account=account.name,
                               domainid=account.domainid,
                               diskofferingid=self.disk_offering.id)
        virtual_machine.attach_volume(self.apiclient, volume)
        virtual_machine.stop(self.apiclient)
        account_network.restart(self.apiclient, cleanup=False)
        time.sleep(self.services["sleep"])
        virtual_machine.restore(self.apiclient)
        time.sleep(self.services["sleep"])
        virtual_machine.detach_volume(self.apiclient, volume)
        volume.delete(self.apiclient)
        ts = str(time.time())
        virtual_machine.update(self.apiclient, displayname=ts)
        virtual_machine.delete(self.apiclient)
        account_network.update(self.apiclient, name=account_network.name + ts)
        account_network.delete(self.apiclient)
        account.update(self.apiclient, newname=account.name + ts)
        account.disable(self.apiclient)
        account.delete(self.apiclient)
        domain1.delete(self.apiclient)

        cmd = listEvents.listEventsCmd()
        cmd.startdate = start_time
        cmd.listall = True
        events = self.apiclient.listEvents(cmd)
        self.assertEqual(isinstance(events, list), True,
                         "List Events response was not a valid list")
        self.assertNotEqual(len(events), 0,
                            "List Events returned an empty list")

        for event in events:
            if event.type.startswith("VM.") or (
                    event.type.startswith("NETWORK.")
                    and not event.type.startswith("NETWORK.ELEMENT")
            ) or event.type.startswith("VOLUME.") or event.type.startswith(
                    "ACCOUNT.") or event.type.startswith(
                        "DOMAIN.") or event.type.startswith("TEMPLATE."):
                if event.resourceid is None or event.resourcetype is None:
                    self.debug("Failed event:: %" % event)
                    self.fail(
                        "resourceid or resourcetype for the event not found!")
                else:
                    self.debug(
                        "Event %s at %s:: Resource Type: %s, Resource ID: %s" %
                        (event.type, event.created, event.resourcetype,
                         event.resourceid))
Пример #4
0
def list_events(apiclient, **kwargs):
    """Lists events"""

    cmd = listEvents.listEventsCmd()
    [setattr(cmd, k, v) for k, v in kwargs.items()]
    return(apiclient.listEvents(cmd))
Пример #5
0
def list_events(apiclient, **kwargs):
    """Lists events"""

    cmd = listEvents.listEventsCmd()
    [setattr(cmd, k, v) for k, v in kwargs.items()]
    return (apiclient.listEvents(cmd))