libvirt/src/test.c

/*
 * test.c: A "mock" hypervisor for use by application unit tests
 *
 * Copyright (C) 2006 Red Hat, Inc.
 *
 * See COPYING.LIB for the License of this software
 *
 * Daniel Berrange <berrange@redhat.com>
 */

#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/uri.h>
#include <fcntl.h>
#include <unistd.h>

#include "internal.h"
#include "test.h"
#include "xml.h"

static virDriver testDriver = {
  VIR_DRV_TEST,
  "Test",
  LIBVIR_VERSION_NUMBER,
  NULL, /* init */
  testOpen, /* open */
  testClose, /* close */
  NULL, /* type */
  testGetVersion, /* version */
  testNodeGetInfo, /* nodeGetInfo */
  testListDomains, /* listDomains */
  testNumOfDomains, /* numOfDomains */
  testDomainCreateLinux, /* domainCreateLinux */
  testLookupDomainByID, /* domainLookupByID */
  testLookupDomainByUUID, /* domainLookupByUUID */
  testLookupDomainByName, /* domainLookupByName */
  testPauseDomain, /* domainSuspend */
  testResumeDomain, /* domainResume */
  testShutdownDomain, /* domainShutdown */
  testRebootDomain, /* domainReboot */
  testDestroyDomain, /* domainDestroy */
  NULL, /* domainFree */
  NULL, /* domainGetName */
  NULL, /* domainGetID */
  NULL, /* domainGetUUID */
  testGetOSType, /* domainGetOSType */
  testGetMaxMemory, /* domainGetMaxMemory */
  testSetMaxMemory, /* domainSetMaxMemory */
  testSetMemory, /* domainSetMemory */
  testGetDomainInfo, /* domainGetInfo */
  NULL, /* domainSave */
  NULL, /* domainRestore */
  NULL, /* domainCoreDump */
  testSetVcpus, /* domainSetVcpus */
  NULL, /* domainPinVcpu */
  NULL, /* domainGetVcpus */
  testDomainDumpXML, /* domainDumpXML */
  NULL, /* listDefinedDomains */
  NULL, /* numOfDefinedDomains */
  NULL, /* domainCreate */
  NULL, /* domainDefineXML */
  NULL, /* domainUndefine */
  NULL, /* domainAttachDevice */
  NULL, /* domainDetachDevice */
};

/* Amount of time it takes to shutdown */
#define SHUTDOWN_DURATION 15

typedef struct _testDev {
  char name[20];
  virDeviceMode mode;
} testDev;

#define MAX_DEVICES 10

typedef struct _testDom {
  int active;
  char name[20];
  unsigned char uuid[16];
  virDomainKernel kernel;
  virDomainInfo info;
  time_t shutdownStartedAt;
  virDomainRestart onRestart; /* What to do at end of current shutdown procedure */
  virDomainRestart onReboot;
  virDomainRestart onPoweroff;
  virDomainRestart onCrash;
  int numDevices;
  testDev devices[MAX_DEVICES];
} testDom;

#define MAX_DOMAINS 20

typedef struct _testCon {
  int active;
  virNodeInfo nodeInfo;
  int numDomains;
  testDom domains[MAX_DOMAINS];
} testCon;

#define MAX_CONNECTIONS 5

typedef struct _testNode {
  int numConnections;
  testCon connections[MAX_CONNECTIONS];
} testNode;

/* XXX, how about we stuff this in a SHM
   segment so multiple apps can run tests
   against the mock hypervisor concurrently.
   Would need a pthread process shared mutex
   too probably */
static testNode *node = NULL;

static const virNodeInfo defaultNodeInfo = {
  "i686",
  1024*1024*3, /* 3 GB */
  16,
  1400,
  2,
  2,
  2,
  2,
};

static void
testError(virConnectPtr con,
	  virDomainPtr dom,
	  virErrorNumber error,
	  const char *info)
{
  const char *errmsg;

  if (error == VIR_ERR_OK)
    return;

  errmsg = __virErrorMsg(error, info);
  __virRaiseError(con, dom, VIR_FROM_XEN, error, VIR_ERR_ERROR,
		  errmsg, info, NULL, 0, 0, errmsg, info, 0);
}

static int testRestartStringToFlag(const char *str) {
  if (!strcmp(str, "restart")) {
    return VIR_DOMAIN_RESTART;
  } else if (!strcmp(str, "destroy")) {
    return VIR_DOMAIN_DESTROY;
  } else if (!strcmp(str, "preserve")) {
    return VIR_DOMAIN_PRESERVE;
  } else if (!strcmp(str, "rename-restart")) {
    return VIR_DOMAIN_RENAME_RESTART;
  } else {
    return 0;
  }
}

static const char *testRestartFlagToString(int flag) {
  switch (flag) {
  case VIR_DOMAIN_RESTART:
    return "restart";
  case VIR_DOMAIN_DESTROY:
    return "destroy";
  case VIR_DOMAIN_PRESERVE:
    return "preserve";
  case VIR_DOMAIN_RENAME_RESTART:
    return "rename-restart";
  }
  return NULL;
}

/**
 * testRegister:
 *
 * Registers the test driver
 */
void testRegister(void)
{
  virRegisterDriver(&testDriver);
}

static int testLoadDomain(virConnectPtr conn,
			  int domid,
			  xmlDocPtr xml) {
  xmlNodePtr root = NULL;
  xmlXPathContextPtr ctxt = NULL;
  xmlXPathObjectPtr obj = NULL;
  char *name = NULL;
  unsigned char rawuuid[16];
  char *dst_uuid;
  testCon *con;
  struct timeval tv;
  unsigned long memory;
  int nrVirtCpu;
  char *conv;
  virDomainRestart onReboot = VIR_DOMAIN_RESTART;
  virDomainRestart onPoweroff = VIR_DOMAIN_DESTROY;
  virDomainRestart onCrash = VIR_DOMAIN_RENAME_RESTART;

  if (gettimeofday(&tv, NULL) < 0) {
    testError(conn, NULL, VIR_ERR_INTERNAL_ERROR, _("getting time of day"));
    return -1;
  }

  root = xmlDocGetRootElement(xml);
  if ((root == NULL) || (!xmlStrEqual(root->name, BAD_CAST "domain"))) {
    testError(conn, NULL, VIR_ERR_XML_ERROR, _("domain"));
    goto error;
  }

  ctxt = xmlXPathNewContext(xml);
  if (ctxt == NULL) {
    testError(conn, NULL, VIR_ERR_INTERNAL_ERROR, _("creating xpath context"));
    goto error;
  }

  obj = xmlXPathEval(BAD_CAST "string(/domain/name[1])", ctxt);
  if ((obj == NULL) || (obj->type != XPATH_STRING) ||
      (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
    testError(conn, NULL, VIR_ERR_INTERNAL_ERROR, _("domain name"));
    goto error;
  }
  name = strdup((const char *)obj->stringval);
  xmlXPathFreeObject(obj);

  obj = xmlXPathEval(BAD_CAST "string(/domain/uuid[1])", ctxt);
  if ((obj == NULL) || (obj->type != XPATH_STRING) ||
      (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
    testError(conn, NULL, VIR_ERR_XML_ERROR, _("domain uuid"));
    goto error;
  }
  dst_uuid = (char *) &rawuuid[0];
  if (!(virParseUUID((char **)&dst_uuid, (const char *)obj->stringval))) {
    testError(conn, NULL, VIR_ERR_XML_ERROR, _("domain uuid"));
    goto error;
  }
  xmlXPathFreeObject(obj);

  obj = xmlXPathEval(BAD_CAST "string(/domain/memory[1])", ctxt);
  if ((obj == NULL) || (obj->type != XPATH_STRING) ||
      (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
    testError(conn, NULL, VIR_ERR_XML_ERROR, _("domain memory"));
    goto error;
  }
  memory = strtoll((const char*)obj->stringval, &conv, 10);
  if (conv == (const char*)obj->stringval) {
    testError(conn, NULL, VIR_ERR_XML_ERROR, _("domain memory"));
    goto error;
  }
  xmlXPathFreeObject(obj);

  obj = xmlXPathEval(BAD_CAST "string(/domain/vcpu[1])", ctxt);
  if ((obj == NULL) || (obj->type != XPATH_STRING) ||
      (obj->stringval == NULL) || (obj->stringval[0] == 0)) {
    nrVirtCpu = 1;
  } else {
    nrVirtCpu = strtoll((const char*)obj->stringval, &conv, 10);
    if (conv == (const char*)obj->stringval) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("domain vcpus"));
      goto error;
    }
  }
  if (obj)
    xmlXPathFreeObject(obj);

  obj = xmlXPathEval(BAD_CAST "string(/domain/on_reboot[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    if (!(onReboot = testRestartStringToFlag((const char *)obj->stringval))) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("domain reboot behaviour"));
      goto error;
    }
  }
  if (obj)
    xmlXPathFreeObject(obj);

  obj = xmlXPathEval(BAD_CAST "string(/domain/on_poweroff[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    if (!(onReboot = testRestartStringToFlag((const char *)obj->stringval))) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("domain poweroff behaviour"));
      goto error;
    }
  }
  if (obj)
    xmlXPathFreeObject(obj);

  obj = xmlXPathEval(BAD_CAST "string(/domain/on_crash[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    if (!(onReboot = testRestartStringToFlag((const char *)obj->stringval))) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("domain crash behaviour"));
      goto error;
    }
  }
  if (obj)
    xmlXPathFreeObject(obj);

  con = &node->connections[conn->handle];

  con->domains[domid].active = 1;
  strncpy(con->domains[domid].name, name, sizeof(con->domains[domid].name));
  free(name);
  name = NULL;

  memmove(con->domains[domid].uuid, rawuuid, 16);
  con->domains[domid].info.maxMem = memory;
  con->domains[domid].info.memory = memory;
  con->domains[domid].info.state = VIR_DOMAIN_RUNNING;
  con->domains[domid].info.nrVirtCpu = nrVirtCpu;
  con->domains[domid].info.cpuTime = ((tv.tv_sec * 1000ll * 1000ll  * 1000ll) + (tv.tv_usec * 1000ll));

  con->domains[domid].onReboot = onReboot;
  con->domains[domid].onPoweroff = onPoweroff;
  con->domains[domid].onCrash = onCrash;

  return 0;

 error:
  if (obj)
    xmlXPathFreeObject(obj);
  if (name)
    free(name);
  return -1;
}

static int testLoadDomainFromDoc(virConnectPtr conn,
				 int domid,
				 const char *doc) {
  int ret;
  xmlDocPtr xml;
  if (!(xml = xmlReadDoc(BAD_CAST doc, "domain.xml", NULL,
			 XML_PARSE_NOENT | XML_PARSE_NONET |
			 XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) {
    testError(NULL, NULL, VIR_ERR_XML_ERROR, _("domain"));
    return -1;
  }

  ret = testLoadDomain(conn, domid, xml);

  xmlFreeDoc(xml);

  return ret;
}

static int testLoadDomainFromFile(virConnectPtr conn,
				  int domid,
				  const char *file) {
  int ret, fd;
  xmlDocPtr xml;

  if ((fd = open(file, O_RDONLY)) < 0) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("load domain definition file"));
    return -1;
  }

  if (!(xml = xmlReadFd(fd, file, NULL,
			XML_PARSE_NOENT | XML_PARSE_NONET |
			XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) {
    testError(NULL, NULL, VIR_ERR_XML_ERROR, _("domain"));
    close(fd);
    return -1;
  }
  close(fd);

  ret = testLoadDomain(conn, domid, xml);

  xmlFreeDoc(xml);

  return ret;
}


static int testOpenDefault(virConnectPtr conn,
			   int connid) {
  int u;
  struct timeval tv;

  if (gettimeofday(&tv, NULL) < 0) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("getting time of day"));
    return -1;
  }

  conn->handle = connid;
  node->connections[connid].active = 1;
  memmove(&node->connections[connid].nodeInfo, &defaultNodeInfo, sizeof(defaultNodeInfo));

  node->connections[connid].numDomains = 1;
  node->connections[connid].domains[0].active = 1;
  strcpy(node->connections[connid].domains[0].name, "Domain-0");
  for (u = 0 ; u < 16 ; u++) {
    node->connections[connid].domains[0].uuid[u] = (u * 75)%255;
  }
  node->connections[connid].domains[0].info.maxMem = 8192 * 1024;
  node->connections[connid].domains[0].info.memory = 2048 * 1024;
  node->connections[connid].domains[0].info.state = VIR_DOMAIN_RUNNING;
  node->connections[connid].domains[0].info.nrVirtCpu = 2;
  node->connections[connid].domains[0].info.cpuTime = ((tv.tv_sec * 1000ll * 1000ll  * 1000ll) + (tv.tv_usec * 1000ll));
  return 0;
}


static char *testBuildFilename(const char *relativeTo,
			       const char *filename) {
  char *offset;
  int baseLen;
  if (!filename || filename[0] == '\0')
    return NULL;
  if (filename[0] == '/')
    return strdup(filename);

  offset = rindex(relativeTo, '/');
  if ((baseLen = (offset-relativeTo+1))) {
    char *absFile = malloc(baseLen + strlen(filename) + 1);
    strncpy(absFile, relativeTo, baseLen);
    absFile[baseLen] = '\0';
    strcat(absFile, filename);
    return absFile;
  } else {
    return strdup(filename);
  }
}

static int testOpenFromFile(virConnectPtr conn,
			    int connid,
			    const char *file) {
  int fd, i;
  xmlDocPtr xml;
  xmlNodePtr root = NULL;
  xmlXPathContextPtr ctxt = NULL;
  xmlXPathObjectPtr obj = NULL;
  virNodeInfoPtr nodeInfo;

  if ((fd = open(file, O_RDONLY)) < 0) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("loading host definition file"));
    return -1;
  }

  if (!(xml = xmlReadFd(fd, file, NULL,
			XML_PARSE_NOENT | XML_PARSE_NONET |
			XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("host"));
    goto error;
  }
  close(fd);
  fd = -1;

  root = xmlDocGetRootElement(xml);
  if ((root == NULL) || (!xmlStrEqual(root->name, BAD_CAST "node"))) {
    testError(NULL, NULL, VIR_ERR_XML_ERROR, _("node"));
    goto error;
  }

  ctxt = xmlXPathNewContext(xml);
  if (ctxt == NULL) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("creating xpath context"));
    goto error;
  }

  conn->handle = connid;
  node->connections[connid].active = 1;
  node->connections[connid].numDomains = 0;
  memmove(&node->connections[connid].nodeInfo, &defaultNodeInfo, sizeof(defaultNodeInfo));

  nodeInfo = &node->connections[connid].nodeInfo;
  obj = xmlXPathEval(BAD_CAST "string(/node/cpu/nodes[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    char *conv = NULL;
    nodeInfo->nodes = strtol((const char*)obj->stringval, &conv, 10);
    if (conv == (const char*)obj->stringval) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("node cpu numa nodes"));
      goto error;
    }
    xmlXPathFreeObject(obj);
  }

  obj = xmlXPathEval(BAD_CAST "string(/node/cpu/sockets[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    char *conv = NULL;
    nodeInfo->sockets = strtol((const char*)obj->stringval, &conv, 10);
    if (conv == (const char*)obj->stringval) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("node cpu sockets"));
      goto error;
    }
    xmlXPathFreeObject(obj);
  }

  obj = xmlXPathEval(BAD_CAST "string(/node/cpu/cores[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    char *conv = NULL;
    nodeInfo->cores = strtol((const char*)obj->stringval, &conv, 10);
    if (conv == (const char*)obj->stringval) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("node cpu cores"));
      goto error;
    }
    xmlXPathFreeObject(obj);
  }

  obj = xmlXPathEval(BAD_CAST "string(/node/cpu/threads[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    char *conv = NULL;
    nodeInfo->threads = strtol((const char*)obj->stringval, &conv, 10);
    if (conv == (const char*)obj->stringval) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("node cpu threads"));
      goto error;
    }
    xmlXPathFreeObject(obj);
  }
  nodeInfo->cpus = nodeInfo->cores * nodeInfo->threads * nodeInfo->sockets * nodeInfo->nodes;
  obj = xmlXPathEval(BAD_CAST "string(/node/cpu/active[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    char *conv = NULL;
    unsigned int active = strtol((const char*)obj->stringval, &conv, 10);    
    if (conv == (const char*)obj->stringval) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("node active cpu"));
      goto error;
    }
    if (active < nodeInfo->cpus) {
      nodeInfo->cpus = active;
    }
    xmlXPathFreeObject(obj);
  }
  obj = xmlXPathEval(BAD_CAST "string(/node/cpu/mhz[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    char *conv = NULL;
    nodeInfo->mhz = strtol((const char*)obj->stringval, &conv, 10);
    if (conv == (const char*)obj->stringval) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("node cpu mhz"));
      goto error;
    }
    xmlXPathFreeObject(obj);
  }
  obj = xmlXPathEval(BAD_CAST "string(/node/cpu/model[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    strncpy(nodeInfo->model, (const char *)obj->stringval, sizeof(nodeInfo->model)-1);
    nodeInfo->model[sizeof(nodeInfo->model)-1] = '\0';
    xmlXPathFreeObject(obj);
  }

  obj = xmlXPathEval(BAD_CAST "string(/node/memory[1])", ctxt);
  if ((obj != NULL) && (obj->type == XPATH_STRING) &&
      (obj->stringval != NULL) && (obj->stringval[0] != 0)) {
    char *conv = NULL;
    nodeInfo->memory = strtol((const char*)obj->stringval, &conv, 10);
    if (conv == (const char*)obj->stringval) {
      testError(conn, NULL, VIR_ERR_XML_ERROR, _("node memory"));
      goto error;
    }
    xmlXPathFreeObject(obj);
  }

  obj = xmlXPathEval(BAD_CAST "/node/domain", ctxt);
  if ((obj == NULL) || (obj->type != XPATH_NODESET) ||
      (obj->nodesetval == NULL)) {
    testError(NULL, NULL, VIR_ERR_XML_ERROR, _("node domain list"));
    goto error;
  }

  for (i = 0 ; i < obj->nodesetval->nodeNr ; i++) {
    xmlChar *domFile = xmlGetProp(obj->nodesetval->nodeTab[i], BAD_CAST "file");
    char *absFile = testBuildFilename(file, (const char *)domFile);
    free(domFile);
    if (!absFile) {
      testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("resolving domain filename"));
      goto error;
    }
    if (testLoadDomainFromFile(conn, i, absFile) != 0) {
      free(absFile);
      goto error;
    }
    free(absFile);
    node->connections[connid].numDomains++;
  }

  xmlXPathFreeObject(obj);
  xmlFreeDoc(xml);

  return 0;

 error:
  if (node->connections[connid].active) {
    for (i = 0 ; i <node->connections[connid].numDomains ; i++) {
      node->connections[connid].domains[i].active = 0;
    }
    node->connections[connid].numDomains = 0;
    node->connections[connid].active = 0;
  }
  if (obj)
    xmlXPathFreeObject(obj);
  if (xml)
    xmlFreeDoc(xml);
  if (fd != -1)
    close(fd);
  return -1;
}

static int getNextConnection(void) {
  int i;
  if (node == NULL) {
    node = calloc(1, sizeof(testNode));
    if (!node) {
      testError(NULL, NULL, VIR_ERR_NO_MEMORY, _("allocating node"));
      return -1;
    }
  }

  for (i = 0 ; i < MAX_CONNECTIONS ; i++) {
    if (!node->connections[i].active) {
      return i;
    }
  }
  return -1;
}

int testOpen(virConnectPtr conn,
             const char *name,
             int flags)
{
  xmlURIPtr uri;
  int ret, connid;

  if (!name) {
    return -1;
  }

  uri = xmlParseURI(name);
  if (uri == NULL) {
    if (!(flags & VIR_DRV_OPEN_QUIET))
      testError(conn, NULL, VIR_ERR_NO_SUPPORT, name);
    return(-1);
  }

  if (!uri->scheme ||
      strcmp(uri->scheme, "test") ||
      !uri->path) {
    xmlFreeURI(uri);
    return -1;
  }


  if ((connid = getNextConnection()) < 0) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("too many connections"));
    return -1;
  }

  if (!strcmp(uri->path, "/default")) {
    ret = testOpenDefault(conn,
			  connid);
  } else {
    ret = testOpenFromFile(conn,
			   connid,
			   uri->path);
  }

  xmlFreeURI(uri);

  return (ret);
}

int testClose(virConnectPtr conn)
{
  testCon *con = &node->connections[conn->handle];
  con->active = 0;
  conn->handle = -1;
  memset(con, 0, sizeof(testCon));
  return 0;
}

int testGetVersion(virConnectPtr conn ATTRIBUTE_UNUSED,
                   unsigned long *hvVer)
{
  *hvVer = 2;
  return 0;
}

int testNodeGetInfo(virConnectPtr conn,
                    virNodeInfoPtr info)
{
  testCon *con = &node->connections[conn->handle];
  memcpy(info, &con->nodeInfo, sizeof(virNodeInfo));
  return 0;
}

int testNumOfDomains(virConnectPtr conn)
{
  testCon *con = &node->connections[conn->handle];
  return con->numDomains;
}

virDomainPtr
testDomainCreateLinux(virConnectPtr conn, const char *xmlDesc,
		      unsigned int flags ATTRIBUTE_UNUSED)
{
  testCon *con;
  int i;
  virDomainPtr dom;

  if (!VIR_IS_CONNECT(conn)) {
    testError(conn, NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
    return (NULL);
  }
  if (xmlDesc == NULL) {
    testError(conn, NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
    return (NULL);
  }
  if (conn->flags & VIR_CONNECT_RO) {
    testError(conn, NULL, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
    return (NULL);
  }
  
  con = &node->connections[conn->handle];

  for (i = 0 ; i < MAX_DOMAINS ; i++) {
    if (!con->domains[i].active) {
      if (testLoadDomainFromDoc(conn, i, xmlDesc) < 0)
	return NULL;
      dom = virGetDomain(conn, con->domains[i].name, con->domains[i].uuid);
      if (dom == NULL) {
	testError(conn, NULL, VIR_ERR_NO_MEMORY, _("allocating domain"));
	return NULL;
      }
      con->numDomains++;
      return dom;
    }
  }
  
  testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("too many domains"));
  return (NULL);
}


virDomainPtr testLookupDomainByID(virConnectPtr conn,
                                  int id)
{
  testCon *con = &node->connections[conn->handle];
  virDomainPtr dom;

  if (!con->domains[id].active) {
    return NULL;
  }

  dom = virGetDomain(conn, con->domains[id].name, con->domains[id].uuid);
  if (dom == NULL) {
    testError(conn, NULL, VIR_ERR_NO_MEMORY, _("allocating domain"));
    return(NULL);
  }
  dom->handle = id;
  return dom;
}

virDomainPtr testLookupDomainByUUID(virConnectPtr conn,
                                    const unsigned char *uuid)
{
  testCon *con = &node->connections[conn->handle];
  virDomainPtr dom = NULL;
  int i, id = -1;
  for (i = 0 ; i < MAX_DOMAINS ; i++) {
    if (con->domains[i].active &&
	memcmp(uuid, con->domains[i].uuid, 16) == 0) {
      id = i;
      break;
    }
  }
  if (id >= 0) {
    dom = virGetDomain(conn, con->domains[id].name, con->domains[id].uuid);
    if (dom == NULL) {
      testError(conn, NULL, VIR_ERR_NO_MEMORY, _("allocating domain"));
      return(NULL);
    }
    dom->handle = id;
  }
  return dom;
}

virDomainPtr testLookupDomainByName(virConnectPtr conn,
                                    const char *name)
{
  testCon *con = &node->connections[conn->handle];
  virDomainPtr dom = NULL;
  int i, id = -1;
  for (i = 0 ; i < MAX_DOMAINS ; i++) {
    if (con->domains[i].active &&
	strcmp(name, con->domains[i].name) == 0) {
      id = i;
      break;
    }
  }
  if (id >= 0) {
    dom = virGetDomain(conn, con->domains[id].name, con->domains[id].uuid);
    if (dom == NULL) {
      testError(conn, NULL, VIR_ERR_NO_MEMORY, _("allocating domain"));
      return(NULL);
    }
    dom->handle = id;
  }
  return dom;
}

int testListDomains (virConnectPtr conn,
                     int *ids,
                     int maxids)
{
  testCon *con = &node->connections[conn->handle];
  int n, i;

  for (i = 0, n = 0 ; i < MAX_DOMAINS && n < maxids ; i++) {
    if (con->domains[i].active) {
      ids[n++] = i;
    }
  }
  return n;
}

int testDestroyDomain (virDomainPtr domain)
{
  testCon *con;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(-1);
  }
  if (domain->conn->flags & VIR_CONNECT_RO) {
    testError(domain->conn, domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
    return (-1);
  }
  
  con = &node->connections[domain->conn->handle];
  con->domains[domain->handle].active = 0;
  return (0);
}

int testResumeDomain (virDomainPtr domain)
{
  testCon *con;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(-1);
  }
  if (domain->conn->flags & VIR_CONNECT_RO) {
    testError(domain->conn, domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
    return (-1);
  }

  con = &node->connections[domain->conn->handle];
  con->domains[domain->handle].info.state = VIR_DOMAIN_RUNNING;
  return 0;
}

int testPauseDomain (virDomainPtr domain)
{
  testCon *con;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(-1);
  }
  if (domain->conn->flags & VIR_CONNECT_RO) {
    testError(domain->conn, domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
    return (-1);
  }

  con = &node->connections[domain->conn->handle];
  con->domains[domain->handle].info.state = VIR_DOMAIN_PAUSED;
  return (0);
}

/* We don't do an immediate shutdown. We basically pretend that
   out shutdown sequence takes 'n' seconds to complete. SO, here
   we just set state to shutdown, and subsquent calls to getDomainInfo
   will check to see if shutdown ought to be marked complete. */
int testShutdownDomain (virDomainPtr domain)
{
  testCon *con;
  struct timeval tv;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return (-1);
  }
  if (domain->conn->flags & VIR_CONNECT_RO) {
    testError(domain->conn, domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
    return (-1);
  }

  con = &node->connections[domain->conn->handle];

  if (gettimeofday(&tv, NULL) < 0) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("getting time of day"));
    return (-1);
  }

  con->domains[domain->handle].info.state = VIR_DOMAIN_SHUTDOWN;
  con->domains[domain->handle].onRestart = VIR_DOMAIN_DESTROY;
  con->domains[domain->handle].shutdownStartedAt = tv.tv_sec;
  return (0);
}

/* Similar behaviour as shutdown */
int testRebootDomain (virDomainPtr domain, virDomainRestart action)
{
  testCon *con;
  struct timeval tv;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(-1);
  }
  if (domain->conn->flags & VIR_CONNECT_RO) {
    testError(domain->conn, domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
    return (-1);
  }

  con = &node->connections[domain->conn->handle];

  if (gettimeofday(&tv, NULL) < 0) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("getting time of day"));
    return (-1);
  }

  if (!action)
    action = VIR_DOMAIN_RESTART;

  con->domains[domain->handle].info.state = VIR_DOMAIN_SHUTDOWN;
  con->domains[domain->handle].onRestart = action;
  con->domains[domain->handle].shutdownStartedAt = tv.tv_sec;
  return (0);
}

int testGetDomainInfo (virDomainPtr domain,
                       virDomainInfoPtr info)
{
  struct timeval tv;
  testCon *con;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(-1);
  }

  con = &node->connections[domain->conn->handle];

  if (gettimeofday(&tv, NULL) < 0) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, _("getting time of day"));
    return (-1);
  }

  /* Check to see if there is an in-progresss shutdown/reboot that
     needs to be marked completed now */
  if (con->domains[domain->handle].info.state == VIR_DOMAIN_SHUTDOWN &&
      (tv.tv_sec - con->domains[domain->handle].shutdownStartedAt) > SHUTDOWN_DURATION) {

      switch (con->domains[domain->handle].onRestart) {
      case VIR_DOMAIN_DESTROY:
	con->domains[domain->handle].info.state = VIR_DOMAIN_SHUTOFF;
	break;

      case VIR_DOMAIN_RESTART:
	con->domains[domain->handle].info.state = VIR_DOMAIN_RUNNING;
	break;

      case VIR_DOMAIN_PRESERVE:
	con->domains[domain->handle].info.state = VIR_DOMAIN_SHUTOFF;
	break;

      case VIR_DOMAIN_RENAME_RESTART:
	con->domains[domain->handle].info.state = VIR_DOMAIN_RUNNING;
	break;

      default:
	con->domains[domain->handle].info.state = VIR_DOMAIN_SHUTOFF;
	break;
    }
  }

  if (con->domains[domain->handle].info.state == VIR_DOMAIN_SHUTOFF) {
    con->domains[domain->handle].info.cpuTime = 0;
    con->domains[domain->handle].info.memory = 0;
  } else {
    con->domains[domain->handle].info.cpuTime = ((tv.tv_sec * 1000ll * 1000ll  * 1000ll) + (tv.tv_usec * 1000ll));
  }
  memcpy(info, &con->domains[domain->handle].info, sizeof(virDomainInfo));
  return (0);
}

char *testGetOSType(virDomainPtr dom ATTRIBUTE_UNUSED) {
  return strdup("linux");
}

unsigned long testGetMaxMemory(virDomainPtr domain) {
  testCon *con;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(-1);
  }
  
  con = &node->connections[domain->conn->handle];
  return con->domains[domain->handle].info.maxMem;
}

int testSetMaxMemory (virDomainPtr domain,
                      unsigned long memory)
{
  testCon *con;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(-1);
  }
  if (domain->conn->flags & VIR_CONNECT_RO) {
    testError(domain->conn, domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
    return (-1);
  }

  con = &node->connections[domain->conn->handle];
  /* XXX validate not over host memory wrt to other domains */
  con->domains[domain->handle].info.maxMem = memory;
  return (0);
}

int testSetMemory (virDomainPtr domain,
		   unsigned long memory)
{
  testCon *con;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(-1);
  }
  if (domain->conn->flags & VIR_CONNECT_RO) {
    testError(domain->conn, domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
    return (-1);
  }

  con = &node->connections[domain->conn->handle];

  if (memory > con->domains[domain->handle].info.maxMem) {
    testError(domain->conn, domain, VIR_ERR_INVALID_ARG, __FUNCTION__);
    return (-1);
  }

  con->domains[domain->handle].info.memory = memory;
  return (0);
}

int testSetVcpus(virDomainPtr domain,
		 unsigned int nrCpus) {
  testCon *con;

  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(-1);
  }
  if (domain->conn->flags & VIR_CONNECT_RO) {
    testError(domain->conn, domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
    return (-1);
  }

  con = &node->connections[domain->conn->handle];

  /* We allow more cpus in guest than host */
  if (nrCpus > 32) {
    testError(domain->conn, domain, VIR_ERR_INVALID_ARG, __FUNCTION__);
    return (-1);
  }

  con->domains[domain->handle].info.nrVirtCpu = nrCpus;
  return (0);
}

char * testDomainDumpXML(virDomainPtr domain, int flags ATTRIBUTE_UNUSED)
{
  virBufferPtr buf;
  char *xml;
  unsigned char *uuid;
  testCon *con;
  if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) {
    testError((domain ? domain->conn : NULL), domain, VIR_ERR_INVALID_ARG,
	      __FUNCTION__);
    return(NULL);
  }
  
  con = &node->connections[domain->conn->handle];
  
  if (!(buf = virBufferNew(4000))) {
    return (NULL);
  }
  
  virBufferVSprintf(buf, "<domain type='test' id='%d'>\n", domain->handle);
  virBufferVSprintf(buf, "  <name>%s</name>\n", domain->name);
  uuid = domain->uuid;
  virBufferVSprintf(buf,
		    "  <uuid>%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x</uuid>\n",
		    uuid[0], uuid[1], uuid[2], uuid[3],
		    uuid[4], uuid[5], uuid[6], uuid[7],
		    uuid[8], uuid[9], uuid[10], uuid[11],
		    uuid[12], uuid[13], uuid[14], uuid[15]);
  
  virBufferVSprintf(buf, "  <memory>%d</memory>\n", con->domains[domain->handle].info.maxMem);
  virBufferVSprintf(buf, "  <vcpu>%d</vcpu>\n", con->domains[domain->handle].info.nrVirtCpu);
  virBufferVSprintf(buf, "  <on_reboot>%s</on_reboot>\n", testRestartFlagToString(con->domains[domain->handle].onReboot));
  virBufferVSprintf(buf, "  <on_poweroff>%s</on_poweroff>\n", testRestartFlagToString(con->domains[domain->handle].onPoweroff));
  virBufferVSprintf(buf, "  <on_crash>%s</on_crash>\n", testRestartFlagToString(con->domains[domain->handle].onCrash));
  
  virBufferAdd(buf, "</domain>\n", -1);
  
  xml = buf->content;
  free(buf);
  return xml;
}