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/uri.h>

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

static virDriver testDriver = {
  "Test",
  NULL, /* init */
  testOpen, /* open */
  testClose, /* close */
  NULL, /* type */
  testGetVersion, /* version */
  testNodeGetInfo, /* nodeGetInfo */
  testListDomains, /* listDomains */
  testNumOfDomains, /* numOfDomains */
  NULL, /* domainCreateLinux */
  testLookupDomainByID, /* domainLookupByID */
  testLookupDomainByUUID, /* domainLookupByUUID */
  testLookupDomainByName, /* domainLookupByName */
  testPauseDomain, /* domainSuspend */
  testResumeDomain, /* domainResume */
  NULL, /* domainShutdown */
  NULL, /* domainReboot */
  testDestroyDomain, /* domainDestroy */
  NULL, /* domainFree */
  NULL, /* domainGetName */
  NULL, /* domainGetID */
  NULL, /* domainGetUUID */
  NULL, /* domainGetOSType */
  NULL, /* domainGetMaxMemory */
  testSetMaxMemory, /* domainSetMaxMemory */
  NULL, /* domainSetMemory */
  testGetDomainInfo, /* domainGetInfo */
  NULL, /* domainSave */
  NULL /* domainRestore */
};

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;
  virDomainRestart onRestart;
  int numDevices;
  testDev devices[MAX_DEVICES];
} testDom;

#define MAX_DOMAINS 20

typedef struct _testCon {
  int active;
  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 virNodeInfo nodeInfo = {
  "i86",
  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);
}


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


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

  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 ||
      strcmp(uri->path, "/default")) {
    xmlFreeURI(uri);
    return -1;
  }


  xmlFreeURI(uri);

  if (node == NULL) {
    node = calloc(1, sizeof(testNode));
    if (!node) {
      testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, "cannot allocate memory");
      return -1;
    }
  }

  for (i = 0 ; i < MAX_CONNECTIONS ; i++) {
    if (!node->connections[i].active) {
      struct timeval tv;

      if (gettimeofday(&tv, NULL) < 0) {
	testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, "cannot get timeofday");
	return -1;
      }

      conn->handle = i;
      node->connections[i].active = 1;

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


  testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, "too make connections");
  return -1;
}

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,
                   unsigned long *hvVer)
{
  *hvVer = 1;
  return 0;
}

int testNodeGetInfo(virConnectPtr conn,
                    virNodeInfoPtr info)
{
  memcpy(info, &nodeInfo, sizeof(nodeInfo));
  return 0;
}

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

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 = &node->connections[domain->conn->handle];
  con->domains[domain->handle].active = 0;
  return 0;
}

int testResumeDomain (virDomainPtr domain)
{
  testCon *con = &node->connections[domain->conn->handle];
  con->domains[domain->handle].info.state = VIR_DOMAIN_RUNNING;
  return 0;
}

int testPauseDomain (virDomainPtr domain)
{
  testCon *con = &node->connections[domain->conn->handle];
  con->domains[domain->handle].info.state = VIR_DOMAIN_PAUSED;
  return 0;
}

int testGetDomainInfo (virDomainPtr domain,
                       virDomainInfoPtr info)
{
  testCon *con = &node->connections[domain->conn->handle];
  struct timeval tv;
  if (gettimeofday(&tv, NULL) < 0) {
    testError(NULL, NULL, VIR_ERR_INTERNAL_ERROR, "cannot get timeofday");
    return -1;
  }

  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;
}

int testSetMaxMemory (virDomainPtr domain,
                      unsigned long memory)
{
  testCon *con = &node->connections[domain->conn->handle];
  con->domains[domain->handle].info.maxMem = memory;
  return 0;
}