tests/objecteventtest.c

   1 /*
   2  * Copyright (C) 2014 Red Hat, Inc.
   3  * Copyright (C) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library;  If not, see
  17  * <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21
  22 #include "testutils.h"
  23
  24 #include "virerror.h"
  25 #include "virxml.h"
  26
  27 #define VIR_FROM_THIS VIR_FROM_NONE
  28
  29
  30 static const char domainDef[] =
  31 "<domain type='test'>"
  32 "  <name>test-domain</name>"
  33 "  <uuid>77a6fc12-07b5-9415-8abb-a803613f2a40</uuid>"
  34 "  <memory>8388608</memory>"
  35 "  <currentMemory>2097152</currentMemory>"
  36 "  <vcpu>2</vcpu>"
  37 "  <os>"
  38 "    <type>hvm</type>"
  39 "  </os>"
  40 "</domain>";
  41
  42 static const char networkDef[] =
  43 "<network>\n"
  44 "  <name>test</name>\n"
  45 "  <bridge name=\"virbr0\"/>\n"
  46 "  <forward/>\n"
  47 "  <ip address=\"192.168.122.1\" netmask=\"255.255.255.0\">\n"
  48 "    <dhcp>\n"
  49 "      <range start=\"192.168.122.2\" end=\"192.168.122.254\"/>\n"
  50 "    </dhcp>\n"
  51 "  </ip>\n"
  52 "</network>\n";
  53
  54 static const char storagePoolDef[] =
  55 "<pool type='dir'>\n"
  56 "  <name>P</name>\n"
  57 "  <target>\n"
  58 "    <path>/target-path</path>\n"
  59 "  </target>\n"
  60 "</pool>\n";
  61
  62 static const char nodeDeviceDef[] =
  63 "<device>\n"
  64 "  <parent>scsi_host1</parent>\n"
  65 "  <capability type='scsi_host'>\n"
  66 "    <capability type='fc_host'>\n"
  67 "      <wwpn>1000000023452345</wwpn>\n"
  68 "      <wwnn>2000000023452345</wwnn>\n"
  69 "    </capability>\n"
  70 "  </capability>\n"
  71 "</device>\n";
  72
  73 typedef struct {
  74     int startEvents;
  75     int stopEvents;
  76     int defineEvents;
  77     int undefineEvents;
  78     int unexpectedEvents;
  79     int createdEvents;
  80     int deletedEvents;
  81 } lifecycleEventCounter;
  82
  83 static void
  84 lifecycleEventCounter_reset(lifecycleEventCounter *counter)
  85 {
  86     counter->startEvents = 0;
  87     counter->stopEvents = 0;
  88     counter->defineEvents = 0;
  89     counter->undefineEvents = 0;
  90     counter->unexpectedEvents = 0;
  91     counter->createdEvents = 0;
  92     counter->deletedEvents = 0;
  93 }
  94
  95 typedef struct {
  96     virConnectPtr conn;
  97     virNetworkPtr net;
  98     virStoragePoolPtr pool;
  99     virNodeDevicePtr dev;
 100 } objecteventTest;
 101
 102
 103 static int
 104 domainLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED,
 105                   virDomainPtr dom ATTRIBUTE_UNUSED,
 106                   int event,
 107                   int detail ATTRIBUTE_UNUSED,
 108                   void *opaque)
 109 {
 110     lifecycleEventCounter *counter = opaque;
 111
 112     switch (event) {
 113         case VIR_DOMAIN_EVENT_STARTED:
 114             counter->startEvents++;
 115             break;
 116         case VIR_DOMAIN_EVENT_STOPPED:
 117             counter->stopEvents++;
 118             break;
 119         case VIR_DOMAIN_EVENT_DEFINED:
 120             counter->defineEvents++;
 121             break;
 122         case VIR_DOMAIN_EVENT_UNDEFINED:
 123             counter->undefineEvents++;
 124             break;
 125         default:
 126             /* Ignore other events */
 127             break;
 128     }
 129     return 0;
 130 }
 131
 132 static void
 133 networkLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED,
 134                    virNetworkPtr net ATTRIBUTE_UNUSED,
 135                    int event,
 136                    int detail ATTRIBUTE_UNUSED,
 137                    void* opaque)
 138 {
 139     lifecycleEventCounter *counter = opaque;
 140
 141     if (event == VIR_NETWORK_EVENT_STARTED)
 142         counter->startEvents++;
 143     else if (event == VIR_NETWORK_EVENT_STOPPED)
 144         counter->stopEvents++;
 145     else if (event == VIR_NETWORK_EVENT_DEFINED)
 146         counter->defineEvents++;
 147     else if (event == VIR_NETWORK_EVENT_UNDEFINED)
 148         counter->undefineEvents++;
 149 }
 150
 151 static void
 152 storagePoolLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED,
 153                        virStoragePoolPtr pool ATTRIBUTE_UNUSED,
 154                        int event,
 155                        int detail ATTRIBUTE_UNUSED,
 156                        void* opaque)
 157 {
 158     lifecycleEventCounter *counter = opaque;
 159
 160     if (event == VIR_STORAGE_POOL_EVENT_STARTED)
 161         counter->startEvents++;
 162     else if (event == VIR_STORAGE_POOL_EVENT_STOPPED)
 163         counter->stopEvents++;
 164     else if (event == VIR_STORAGE_POOL_EVENT_DEFINED)
 165         counter->defineEvents++;
 166     else if (event == VIR_STORAGE_POOL_EVENT_UNDEFINED)
 167         counter->undefineEvents++;
 168     else if (event == VIR_STORAGE_POOL_EVENT_CREATED)
 169         counter->createdEvents++;
 170     else if (event == VIR_STORAGE_POOL_EVENT_DELETED)
 171         counter->deletedEvents++;
 172 }
 173
 174 static void
 175 storagePoolRefreshCb(virConnectPtr conn ATTRIBUTE_UNUSED,
 176                      virStoragePoolPtr pool ATTRIBUTE_UNUSED,
 177                      void* opaque)
 178 {
 179     int *counter = opaque;
 180
 181     (*counter)++;
 182 }
 183
 184 static void
 185 nodeDeviceLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED,
 186                       virNodeDevicePtr dev ATTRIBUTE_UNUSED,
 187                       int event,
 188                       int detail ATTRIBUTE_UNUSED,
 189                       void* opaque)
 190 {
 191     lifecycleEventCounter *counter = opaque;
 192
 193     if (event == VIR_NODE_DEVICE_EVENT_CREATED)
 194         counter->createdEvents++;
 195     else if (event == VIR_NODE_DEVICE_EVENT_DELETED)
 196         counter->deletedEvents++;
 197 }
 198
 199 static int
 200 testDomainCreateXMLOld(const void *data)
 201 {
 202     const objecteventTest *test = data;
 203     lifecycleEventCounter counter;
 204     virDomainPtr dom = NULL;
 205     int ret = -1;
 206     bool registered = false;
 207
 208     lifecycleEventCounter_reset(&counter);
 209
 210     if (virConnectDomainEventRegister(test->conn,
 211                                       domainLifecycleCb,
 212                                       &counter, NULL) != 0)
 213         goto cleanup;
 214     registered = true;
 215     dom = virDomainCreateXML(test->conn, domainDef, 0);
 216
 217     if (dom == NULL || virEventRunDefaultImpl() < 0)
 218         goto cleanup;
 219
 220     if (counter.startEvents != 1 || counter.unexpectedEvents > 0)
 221         goto cleanup;
 222
 223     if (virConnectDomainEventDeregister(test->conn, domainLifecycleCb) != 0)
 224         goto cleanup;
 225     registered = false;
 226     ret = 0;
 227
 228  cleanup:
 229     if (registered)
 230         virConnectDomainEventDeregister(test->conn, domainLifecycleCb);
 231     if (dom) {
 232         virDomainDestroy(dom);
 233         virDomainFree(dom);
 234     }
 235
 236     return ret;
 237 }
 238
 239 static int
 240 testDomainCreateXMLNew(const void *data)
 241 {
 242     const objecteventTest *test = data;
 243     lifecycleEventCounter counter;
 244     int eventId = VIR_DOMAIN_EVENT_ID_LIFECYCLE;
 245     virDomainPtr dom = NULL;
 246     int id;
 247     int ret = -1;
 248
 249     lifecycleEventCounter_reset(&counter);
 250
 251     id = virConnectDomainEventRegisterAny(test->conn, NULL, eventId,
 252                            VIR_DOMAIN_EVENT_CALLBACK(&domainLifecycleCb),
 253                            &counter, NULL);
 254     if (id < 0)
 255         goto cleanup;
 256     dom = virDomainCreateXML(test->conn, domainDef, 0);
 257
 258     if (dom == NULL || virEventRunDefaultImpl() < 0)
 259         goto cleanup;
 260
 261     if (counter.startEvents != 1 || counter.unexpectedEvents > 0)
 262         goto cleanup;
 263
 264     if (virConnectDomainEventDeregisterAny(test->conn, id) != 0)
 265         goto cleanup;
 266     id = -1;
 267     ret = 0;
 268
 269  cleanup:
 270     if (id >= 0)
 271         virConnectDomainEventDeregisterAny(test->conn, id);
 272     if (dom) {
 273         virDomainDestroy(dom);
 274         virDomainFree(dom);
 275     }
 276
 277     return ret;
 278 }
 279
 280 static int
 281 testDomainCreateXMLMixed(const void *data)
 282 {
 283     const objecteventTest *test = data;
 284     lifecycleEventCounter counter;
 285     virDomainPtr dom;
 286     int ret = -1;
 287     int id1 = -1;
 288     int id2 = -1;
 289     bool registered = false;
 290
 291     lifecycleEventCounter_reset(&counter);
 292
 293     /* Fun with mixing old and new API, also with global and
 294      * per-domain.  Handler should be fired three times, once for each
 295      * registration.  */
 296     dom = virDomainDefineXML(test->conn, domainDef);
 297     if (dom == NULL)
 298         goto cleanup;
 299
 300     id1 = virConnectDomainEventRegisterAny(test->conn, dom,
 301                                            VIR_DOMAIN_EVENT_ID_LIFECYCLE,
 302                            VIR_DOMAIN_EVENT_CALLBACK(&domainLifecycleCb),
 303                                            &counter, NULL);
 304     if (id1 < 0)
 305         goto cleanup;
 306     if (virConnectDomainEventRegister(test->conn,
 307                                       domainLifecycleCb,
 308                                       &counter, NULL) != 0)
 309         goto cleanup;
 310     registered = true;
 311     id2 = virConnectDomainEventRegisterAny(test->conn, NULL,
 312                                            VIR_DOMAIN_EVENT_ID_LIFECYCLE,
 313                            VIR_DOMAIN_EVENT_CALLBACK(&domainLifecycleCb),
 314                                            &counter, NULL);
 315     if (id2 < 0)
 316         goto cleanup;
 317
 318     virDomainUndefine(dom);
 319     virDomainDestroy(dom);
 320     virDomainFree(dom);
 321
 322     dom = virDomainCreateXML(test->conn, domainDef, 0);
 323     if (dom == NULL || virEventRunDefaultImpl() < 0)
 324         goto cleanup;
 325
 326     if (counter.startEvents != 3 || counter.unexpectedEvents > 0)
 327         goto cleanup;
 328
 329     if (virConnectDomainEventDeregister(test->conn, domainLifecycleCb) != 0)
 330         goto cleanup;
 331     registered = false;
 332     if (virConnectDomainEventDeregisterAny(test->conn, id1) != 0)
 333         goto cleanup;
 334     id1 = -1;
 335     if (virConnectDomainEventDeregisterAny(test->conn, id2) != 0)
 336         goto cleanup;
 337     id2 = -1;
 338     ret = 0;
 339
 340  cleanup:
 341     if (id1 >= 0)
 342         virConnectDomainEventDeregisterAny(test->conn, id1);
 343     if (id2 >= 0)
 344         virConnectDomainEventDeregisterAny(test->conn, id2);
 345     if (registered)
 346         virConnectDomainEventDeregister(test->conn, domainLifecycleCb);
 347     if (dom != NULL) {
 348         virDomainUndefine(dom);
 349         virDomainDestroy(dom);
 350         virDomainFree(dom);
 351     }
 352
 353     return ret;
 354 }
 355
 356
 357 static int
 358 testDomainDefine(const void *data)
 359 {
 360     const objecteventTest *test = data;
 361     lifecycleEventCounter counter;
 362     int eventId = VIR_DOMAIN_EVENT_ID_LIFECYCLE;
 363     virDomainPtr dom = NULL;
 364     int id;
 365     int ret = 0;
 366
 367     lifecycleEventCounter_reset(&counter);
 368
 369     id = virConnectDomainEventRegisterAny(test->conn, NULL, eventId,
 370                            VIR_DOMAIN_EVENT_CALLBACK(&domainLifecycleCb),
 371                            &counter, NULL);
 372
 373     /* Make sure the define event is triggered */
 374     dom = virDomainDefineXML(test->conn, domainDef);
 375
 376     if (dom == NULL || virEventRunDefaultImpl() < 0) {
 377         ret = -1;
 378         goto cleanup;
 379     }
 380
 381     if (counter.defineEvents != 1 || counter.unexpectedEvents > 0) {
 382         ret = -1;
 383         goto cleanup;
 384     }
 385
 386     /* Make sure the undefine event is triggered */
 387     virDomainUndefine(dom);
 388
 389     if (virEventRunDefaultImpl() < 0) {
 390         ret = -1;
 391         goto cleanup;
 392     }
 393
 394     if (counter.undefineEvents != 1 || counter.unexpectedEvents > 0) {
 395         ret = -1;
 396         goto cleanup;
 397     }
 398
 399
 400  cleanup:
 401     virConnectDomainEventDeregisterAny(test->conn, id);
 402     if (dom != NULL)
 403         virDomainFree(dom);
 404
 405     return ret;
 406 }
 407
 408 static int
 409 testDomainStartStopEvent(const void *data)
 410 {
 411     const objecteventTest *test = data;
 412     lifecycleEventCounter counter;
 413     int eventId = VIR_DOMAIN_EVENT_ID_LIFECYCLE;
 414     int id;
 415     int ret = -1;
 416     virDomainPtr dom;
 417     virConnectPtr conn2 = NULL;
 418     virDomainPtr dom2 = NULL;
 419
 420     lifecycleEventCounter_reset(&counter);
 421
 422     dom = virDomainLookupByName(test->conn, "test");
 423     if (dom == NULL)
 424         return -1;
 425
 426     id = virConnectDomainEventRegisterAny(test->conn, dom, eventId,
 427                            VIR_DOMAIN_EVENT_CALLBACK(&domainLifecycleCb),
 428                            &counter, NULL);
 429
 430     /* Test domain is started */
 431     virDomainDestroy(dom);
 432     if (virDomainCreate(dom) < 0)
 433         goto cleanup;
 434
 435     if (virEventRunDefaultImpl() < 0)
 436         goto cleanup;
 437
 438     if (counter.startEvents != 1 || counter.stopEvents != 1 ||
 439             counter.unexpectedEvents > 0)
 440         goto cleanup;
 441
 442     /* Repeat the test, but this time, trigger the events via an
 443      * alternate connection.  */
 444     if (!(conn2 = virConnectOpen("test:///default")))
 445         goto cleanup;
 446     if (!(dom2 = virDomainLookupByName(conn2, "test")))
 447         goto cleanup;
 448
 449     if (virDomainDestroy(dom2) < 0)
 450         goto cleanup;
 451     if (virDomainCreate(dom2) < 0)
 452         goto cleanup;
 453
 454     if (virEventRunDefaultImpl() < 0)
 455         goto cleanup;
 456
 457     if (counter.startEvents != 2 || counter.stopEvents != 2 ||
 458             counter.unexpectedEvents > 0)
 459         goto cleanup;
 460
 461     ret = 0;
 462  cleanup:
 463     virConnectDomainEventDeregisterAny(test->conn, id);
 464     virDomainFree(dom);
 465     if (dom2)
 466         virDomainFree(dom2);
 467     if (conn2)
 468         virConnectClose(conn2);
 469
 470     return ret;
 471 }
 472
 473 static int
 474 testNetworkCreateXML(const void *data)
 475 {
 476     const objecteventTest *test = data;
 477     lifecycleEventCounter counter;
 478     virNetworkPtr net;
 479     int id;
 480     int ret = 0;
 481
 482     lifecycleEventCounter_reset(&counter);
 483
 484     id = virConnectNetworkEventRegisterAny(test->conn, NULL,
 485                            VIR_NETWORK_EVENT_ID_LIFECYCLE,
 486                            VIR_NETWORK_EVENT_CALLBACK(&networkLifecycleCb),
 487                            &counter, NULL);
 488     net = virNetworkCreateXML(test->conn, networkDef);
 489
 490     if (!net || virEventRunDefaultImpl() < 0) {
 491         ret = -1;
 492         goto cleanup;
 493     }
 494
 495     if (counter.startEvents != 1 || counter.unexpectedEvents > 0) {
 496         ret = -1;
 497         goto cleanup;
 498     }
 499
 500  cleanup:
 501     virConnectNetworkEventDeregisterAny(test->conn, id);
 502     if (net) {
 503         virNetworkDestroy(net);
 504         virNetworkFree(net);
 505     }
 506     return ret;
 507 }
 508
 509 static int
 510 testNetworkDefine(const void *data)
 511 {
 512     const objecteventTest *test = data;
 513     lifecycleEventCounter counter;
 514     virNetworkPtr net;
 515     int id;
 516     int ret = 0;
 517
 518     lifecycleEventCounter_reset(&counter);
 519
 520     id = virConnectNetworkEventRegisterAny(test->conn, NULL,
 521                            VIR_NETWORK_EVENT_ID_LIFECYCLE,
 522                            VIR_NETWORK_EVENT_CALLBACK(&networkLifecycleCb),
 523                            &counter, NULL);
 524
 525     /* Make sure the define event is triggered */
 526     net = virNetworkDefineXML(test->conn, networkDef);
 527
 528     if (!net || virEventRunDefaultImpl() < 0) {
 529         ret = -1;
 530         goto cleanup;
 531     }
 532
 533     if (counter.defineEvents != 1 || counter.unexpectedEvents > 0) {
 534         ret = -1;
 535         goto cleanup;
 536     }
 537
 538     /* Make sure the undefine event is triggered */
 539     virNetworkUndefine(net);
 540
 541     if (virEventRunDefaultImpl() < 0) {
 542         ret = -1;
 543         goto cleanup;
 544     }
 545
 546     if (counter.undefineEvents != 1 || counter.unexpectedEvents > 0) {
 547         ret = -1;
 548         goto cleanup;
 549     }
 550
 551
 552  cleanup:
 553     virConnectNetworkEventDeregisterAny(test->conn, id);
 554     if (net)
 555         virNetworkFree(net);
 556
 557     return ret;
 558 }
 559
 560 static int
 561 testNetworkStartStopEvent(const void *data)
 562 {
 563     const objecteventTest *test = data;
 564     lifecycleEventCounter counter;
 565     int id;
 566     int ret = 0;
 567
 568     if (!test->net)
 569         return -1;
 570
 571     lifecycleEventCounter_reset(&counter);
 572
 573     id = virConnectNetworkEventRegisterAny(test->conn, test->net,
 574                            VIR_NETWORK_EVENT_ID_LIFECYCLE,
 575                            VIR_NETWORK_EVENT_CALLBACK(&networkLifecycleCb),
 576                            &counter, NULL);
 577     virNetworkCreate(test->net);
 578     virNetworkDestroy(test->net);
 579
 580     if (virEventRunDefaultImpl() < 0) {
 581         ret = -1;
 582         goto cleanup;
 583     }
 584
 585     if (counter.startEvents != 1 || counter.stopEvents != 1 ||
 586         counter.unexpectedEvents > 0) {
 587         ret = -1;
 588         goto cleanup;
 589     }
 590  cleanup:
 591     virConnectNetworkEventDeregisterAny(test->conn, id);
 592
 593     return ret;
 594 }
 595
 596 static int
 597 testStoragePoolCreateXML(const void *data)
 598 {
 599     const objecteventTest *test = data;
 600     lifecycleEventCounter counter;
 601     virStoragePoolPtr pool;
 602     int id;
 603     int ret = 0;
 604
 605     lifecycleEventCounter_reset(&counter);
 606
 607     id = virConnectStoragePoolEventRegisterAny(test->conn, NULL,
 608                       VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE,
 609                       VIR_STORAGE_POOL_EVENT_CALLBACK(&storagePoolLifecycleCb),
 610                       &counter, NULL);
 611     pool = virStoragePoolCreateXML(test->conn, storagePoolDef, 0);
 612
 613     if (!pool || virEventRunDefaultImpl() < 0) {
 614         ret = -1;
 615         goto cleanup;
 616     }
 617
 618     if (counter.startEvents != 1 || counter.unexpectedEvents > 0) {
 619         ret = -1;
 620         goto cleanup;
 621     }
 622
 623  cleanup:
 624     virConnectStoragePoolEventDeregisterAny(test->conn, id);
 625     if (pool) {
 626         virStoragePoolDestroy(pool);
 627         virStoragePoolFree(pool);
 628     }
 629     return ret;
 630 }
 631
 632 static int
 633 testStoragePoolDefine(const void *data)
 634 {
 635     const objecteventTest *test = data;
 636     lifecycleEventCounter counter;
 637     virStoragePoolPtr pool;
 638     int id;
 639     int ret = 0;
 640
 641     lifecycleEventCounter_reset(&counter);
 642
 643     id = virConnectStoragePoolEventRegisterAny(test->conn, NULL,
 644                       VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE,
 645                       VIR_STORAGE_POOL_EVENT_CALLBACK(&storagePoolLifecycleCb),
 646                       &counter, NULL);
 647
 648     /* Make sure the define event is triggered */
 649     pool = virStoragePoolDefineXML(test->conn, storagePoolDef, 0);
 650
 651     if (!pool || virEventRunDefaultImpl() < 0) {
 652         ret = -1;
 653         goto cleanup;
 654     }
 655
 656     if (counter.defineEvents != 1 || counter.unexpectedEvents > 0) {
 657         ret = -1;
 658         goto cleanup;
 659     }
 660
 661     /* Make sure the undefine event is triggered */
 662     virStoragePoolUndefine(pool);
 663
 664     if (virEventRunDefaultImpl() < 0) {
 665         ret = -1;
 666         goto cleanup;
 667     }
 668
 669     if (counter.undefineEvents != 1 || counter.unexpectedEvents > 0) {
 670         ret = -1;
 671         goto cleanup;
 672     }
 673
 674
 675  cleanup:
 676     virConnectStoragePoolEventDeregisterAny(test->conn, id);
 677     if (pool)
 678         virStoragePoolFree(pool);
 679
 680     return ret;
 681 }
 682
 683 static int
 684 testStoragePoolStartStopEvent(const void *data)
 685 {
 686     const objecteventTest *test = data;
 687     lifecycleEventCounter counter;
 688     int refreshCounter;
 689     int id1, id2;
 690     int ret = 0;
 691
 692     if (!test->pool)
 693         return -1;
 694
 695     lifecycleEventCounter_reset(&counter);
 696     refreshCounter = 0;
 697
 698     id1 = virConnectStoragePoolEventRegisterAny(test->conn, test->pool,
 699                       VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE,
 700                       VIR_STORAGE_POOL_EVENT_CALLBACK(&storagePoolLifecycleCb),
 701                       &counter, NULL);
 702     id2 = virConnectStoragePoolEventRegisterAny(test->conn, test->pool,
 703                       VIR_STORAGE_POOL_EVENT_ID_REFRESH,
 704                       VIR_STORAGE_POOL_EVENT_CALLBACK(&storagePoolRefreshCb),
 705                       &refreshCounter, NULL);
 706     virStoragePoolCreate(test->pool, 0);
 707     virStoragePoolRefresh(test->pool, 0);
 708     virStoragePoolDestroy(test->pool);
 709
 710     if (virEventRunDefaultImpl() < 0) {
 711         ret = -1;
 712         goto cleanup;
 713     }
 714
 715     if (counter.startEvents != 1 || counter.stopEvents != 1 ||
 716         refreshCounter != 1 || counter.unexpectedEvents > 0) {
 717         ret = -1;
 718         goto cleanup;
 719     }
 720
 721  cleanup:
 722     virConnectStoragePoolEventDeregisterAny(test->conn, id1);
 723     virConnectStoragePoolEventDeregisterAny(test->conn, id2);
 724     return ret;
 725 }
 726
 727 static int
 728 testStoragePoolBuild(const void *data)
 729 {
 730     const objecteventTest *test = data;
 731     lifecycleEventCounter counter;
 732     int id;
 733     int ret = 0;
 734
 735     lifecycleEventCounter_reset(&counter);
 736
 737     id = virConnectStoragePoolEventRegisterAny(test->conn, NULL,
 738                       VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE,
 739                       VIR_STORAGE_POOL_EVENT_CALLBACK(&storagePoolLifecycleCb),
 740                       &counter, NULL);
 741
 742     virStoragePoolBuild(test->pool, 0);
 743
 744     if (virEventRunDefaultImpl() < 0) {
 745         ret = -1;
 746         goto cleanup;
 747     }
 748
 749     if (counter.createdEvents != 1) {
 750         ret = -1;
 751         goto cleanup;
 752     }
 753
 754  cleanup:
 755     virConnectStoragePoolEventDeregisterAny(test->conn, id);
 756     return ret;
 757 }
 758
 759 static int
 760 testStoragePoolDelete(const void *data)
 761 {
 762     const objecteventTest *test = data;
 763     lifecycleEventCounter counter;
 764     int id;
 765     int ret = 0;
 766
 767     lifecycleEventCounter_reset(&counter);
 768
 769     id = virConnectStoragePoolEventRegisterAny(test->conn, NULL,
 770                       VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE,
 771                       VIR_STORAGE_POOL_EVENT_CALLBACK(&storagePoolLifecycleCb),
 772                       &counter, NULL);
 773
 774     virStoragePoolDelete(test->pool, 0);
 775
 776     if (virEventRunDefaultImpl() < 0) {
 777         ret = -1;
 778         goto cleanup;
 779     }
 780
 781     if (counter.deletedEvents != 1) {
 782         ret = -1;
 783         goto cleanup;
 784     }
 785
 786  cleanup:
 787     virConnectStoragePoolEventDeregisterAny(test->conn, id);
 788     return ret;
 789 }
 790 static int
 791 testNodeDeviceCreateXML(const void *data)
 792 {
 793     const objecteventTest *test = data;
 794     lifecycleEventCounter counter;
 795     virNodeDevicePtr dev;
 796     int id;
 797     int ret = 0;
 798
 799     lifecycleEventCounter_reset(&counter);
 800
 801     id = virConnectNodeDeviceEventRegisterAny(test->conn, NULL,
 802                         VIR_NODE_DEVICE_EVENT_ID_LIFECYCLE,
 803                         VIR_NODE_DEVICE_EVENT_CALLBACK(&nodeDeviceLifecycleCb),
 804                         &counter, NULL);
 805     dev = virNodeDeviceCreateXML(test->conn, nodeDeviceDef, 0);
 806     virNodeDeviceDestroy(dev);
 807
 808     if (!dev || virEventRunDefaultImpl() < 0) {
 809         ret = -1;
 810         goto cleanup;
 811     }
 812
 813     if (counter.createdEvents != 1 || counter.deletedEvents != 1 ||
 814         counter.unexpectedEvents > 0) {
 815         ret = -1;
 816         goto cleanup;
 817     }
 818
 819  cleanup:
 820     virConnectNodeDeviceEventDeregisterAny(test->conn, id);
 821     if (dev)
 822         virNodeDeviceFree(dev);
 823     return ret;
 824 }
 825
 826 static void
 827 timeout(int id ATTRIBUTE_UNUSED, void *opaque ATTRIBUTE_UNUSED)
 828 {
 829     fputs("test taking too long; giving up", stderr);
 830     _exit(EXIT_FAILURE);
 831 }
 832
 833 static int
 834 mymain(void)
 835 {
 836     objecteventTest test = { 0 };
 837     int ret = EXIT_SUCCESS;
 838     int timer;
 839
 840     virEventRegisterDefaultImpl();
 841
 842     /* Set up a timer to abort this test if it takes 10 seconds.  */
 843     if ((timer = virEventAddTimeout(10 * 1000, timeout, NULL, NULL)) < 0)
 844         return EXIT_FAILURE;
 845
 846     if (!(test.conn = virConnectOpen("test:///default")))
 847         return EXIT_FAILURE;
 848
 849     virTestQuiesceLibvirtErrors(false);
 850
 851     /* Domain event tests */
 852     if (virTestRun("Domain createXML start event (old API)",
 853                    testDomainCreateXMLOld, &test) < 0)
 854         ret = EXIT_FAILURE;
 855     if (virTestRun("Domain createXML start event (new API)",
 856                    testDomainCreateXMLNew, &test) < 0)
 857         ret = EXIT_FAILURE;
 858     if (virTestRun("Domain createXML start event (both API)",
 859                    testDomainCreateXMLMixed, &test) < 0)
 860         ret = EXIT_FAILURE;
 861     if (virTestRun("Domain (un)define events", testDomainDefine, &test) < 0)
 862         ret = EXIT_FAILURE;
 863     if (virTestRun("Domain start stop events", testDomainStartStopEvent, &test) < 0)
 864         ret = EXIT_FAILURE;
 865
 866     /* Network event tests */
 867     /* Tests requiring the test network not to be set up*/
 868     if (virTestRun("Network createXML start event ", testNetworkCreateXML, &test) < 0)
 869         ret = EXIT_FAILURE;
 870     if (virTestRun("Network (un)define events", testNetworkDefine, &test) < 0)
 871         ret = EXIT_FAILURE;
 872
 873     /* Define a test network */
 874     if (!(test.net = virNetworkDefineXML(test.conn, networkDef)))
 875         ret = EXIT_FAILURE;
 876     if (virTestRun("Network start stop events ", testNetworkStartStopEvent, &test) < 0)
 877         ret = EXIT_FAILURE;
 878
 879     /* Cleanup */
 880     if (test.net) {
 881         virNetworkUndefine(test.net);
 882         virNetworkFree(test.net);
 883     }
 884
 885     /* Storage pool event tests */
 886     if (virTestRun("Storage pool createXML start event ",
 887                    testStoragePoolCreateXML, &test) < 0)
 888         ret = EXIT_FAILURE;
 889     if (virTestRun("Storage pool (un)define events",
 890                    testStoragePoolDefine, &test) < 0)
 891         ret = EXIT_FAILURE;
 892
 893     /* Define a test storage pool */
 894     if (!(test.pool = virStoragePoolDefineXML(test.conn, storagePoolDef, 0)))
 895         ret = EXIT_FAILURE;
 896     if (virTestRun("Storage pool start stop events ",
 897                    testStoragePoolStartStopEvent, &test) < 0)
 898         ret = EXIT_FAILURE;
 899     /* Storage pool build and delete events */
 900     if (virTestRun("Storage pool build event ",
 901                    testStoragePoolBuild, &test) < 0)
 902         ret = EXIT_FAILURE;
 903     if (virTestRun("Storage pool delete event ",
 904                    testStoragePoolDelete, &test) < 0)
 905         ret = EXIT_FAILURE;
 906
 907     /* Node device event tests */
 908     if (virTestRun("Node device createXML add event ",
 909                    testNodeDeviceCreateXML, &test) < 0)
 910         ret = EXIT_FAILURE;
 911
 912     /* Cleanup */
 913     if (test.pool) {
 914         virStoragePoolUndefine(test.pool);
 915         virStoragePoolFree(test.pool);
 916     }
 917
 918     virConnectClose(test.conn);
 919     virEventRemoveTimeout(timer);
 920
 921     return ret;
 922 }
 923
 924 VIR_TEST_MAIN(mymain)