feat: domain resume and suspend (#47)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
- Added the ability to suspend and resume virtual machines, providing
enhanced lifecycle management.

- **Tests**
- Expanded testing to verify that virtual machines properly transition
between running, paused, and shutdown states.

- **Chores**
- Streamlined the Docker testing workflow by simplifying build and run
commands for improved efficiency.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: elibosley

__tests__/domain-lifecycle.test.ts

@@ -172,4 +172,119 @@ describe('Domain Lifecycle Tests', () => {
             domain = null;
         }
     }, 60000);
+
+    it('should handle suspend and resume operations', async () => {
+        // Create a copy of the NVRAM file for this VM
+        if (archConfig.firmware) {
+            execSync(`cp "${archConfig.firmware.vars}" "/tmp/test-vm.nvram"`);
+        }
+
+        // Create a minimal VM configuration
+        const domainDesc: DomainDesc = {
+            type: 'qemu',
+            name: TEST_VM_NAME,
+            memory: { value: 512 * 1024 }, // 512MB RAM
+            vcpu: { value: 1 },
+            os: {
+                type: { 
+                    arch: archConfig.arch,
+                    machine: archConfig.machine,
+                    value: 'hvm'
+                },
+                boot: { dev: 'hd' }
+            },
+            devices: [
+                {
+                    type: 'emulator',
+                    emulator: {
+                        value: archConfig.emulator
+                    }
+                },
+                {
+                    type: 'disk',
+                    disk: {
+                        type: 'file',
+                        device: 'disk',
+                        driver: {
+                            name: 'qemu',
+                            type: 'qcow2'
+                        },
+                        source: {
+                            file: DISK_IMAGE
+                        },
+                        target: {
+                            dev: 'vda',
+                            bus: 'virtio'
+                        }
+                    }
+                },
+                {
+                    type: 'console',
+                    console: {
+                        type: 'pty'
+                    }
+                }
+            ]
+        };
+
+        // Convert domain description to XML
+        const xml = domainDescToXml(domainDesc);
+        console.log('Generated XML:', xml);
+
+        try {
+            // Define and start the domain
+            domain = await connection.domainDefineXML(xml);
+            console.log('Domain defined successfully');
+
+            if (!domain) {
+                throw new Error('Failed to create domain');
+            }
+
+            // Start the domain
+            await domain.create();
+            console.log('Domain created successfully');
+
+            // Verify initial running state
+            const initialInfo = await connection.domainGetInfo(domain);
+            console.log('Initial domain state:', initialInfo.state);
+            expect(initialInfo.state).toBe(DomainState.RUNNING);
+
+            // Suspend the domain
+            await domain.suspend();
+            console.log('Domain suspended');
+
+            // Verify state after suspend
+            const stateAfterSuspend = await connection.domainGetInfo(domain);
+            console.log('Domain state after suspend:', stateAfterSuspend.state);
+            expect(stateAfterSuspend.state).toBe(DomainState.PAUSED);
+
+            // Resume the domain
+            await domain.resume();
+            console.log('Domain resumed');
+
+            // Verify state after resume
+            const stateAfterResume = await connection.domainGetInfo(domain);
+            console.log('Domain state after resume:', stateAfterResume.state);
+            expect(stateAfterResume.state).toBe(DomainState.RUNNING);
+
+            // Clean up by shutting down
+            console.log('Performing cleanup shutdown...');
+            await domain.destroy();
+
+            // Verify final state
+            const finalState = (await domain.getInfo()).state;
+            console.log('Final domain state:', finalState);
+            expect(finalState).toBe(DomainState.SHUTOFF);
+
+            // Undefine the domain
+            await domain.undefine();
+
+        } catch (error) {
+            console.error('Error during VM operations:', error);
+            throw error;
+        } finally {
+            // Clear the domain reference before cleanup
+            domain = null;
+        }
+    }, 60000);
 }); 

lib/domain.spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, beforeEach, vi, expect } from 'vitest';
 import { Domain } from './domain.js';
 import { Hypervisor } from './hypervisor.js';
-import { DomainGetXMLDescFlags } from './types.js';
+import { DomainGetXMLDescFlags, DomainState } from './types.js';
 
 describe('Domain', () => {
     let domain: Domain;
@@ -16,7 +16,7 @@ describe('Domain', () => {
         const domainUndefine = vi.fn();
         const domainGetXMLDesc = vi.fn().mockResolvedValue('<domain/>');
         const domainGetInfo = vi.fn().mockResolvedValue({
-            state: 1,
+            state: DomainState.RUNNING,
             maxMem: 1024,
             memory: 512,
             nrVirtCpu: 1,
@@ -25,6 +25,8 @@ describe('Domain', () => {
         const domainGetID = vi.fn().mockResolvedValue(1);
         const domainGetName = vi.fn().mockResolvedValue('test-vm');
         const domainGetUUIDString = vi.fn().mockResolvedValue('123e4567-e89b-12d3-a456-426614174000');
+        const domainSuspend = vi.fn();
+        const domainResume = vi.fn();
 
         // Create mock hypervisor
         hypervisor = {
@@ -37,7 +39,9 @@ describe('Domain', () => {
             domainGetInfo,
             domainGetID,
             domainGetName,
-            domainGetUUIDString
+            domainGetUUIDString,
+            domainSuspend,
+            domainResume
         } as unknown as Hypervisor;
 
         // Mock the native domain
@@ -83,4 +87,18 @@ describe('Domain', () => {
             expect(hypervisor.domainGetUUIDString).toHaveBeenCalledWith(domain);
         });
     });
+
+    describe('suspend', () => {
+        it('should suspend the domain', async () => {
+            await domain.suspend();
+            expect(hypervisor.domainSuspend).toHaveBeenCalledWith(domain);
+        });
+    });
+
+    describe('resume', () => {
+        it('should resume the domain', async () => {
+            await domain.resume();
+            expect(hypervisor.domainResume).toHaveBeenCalledWith(domain);
+        });
+    });
 }); 

lib/domain.ts

@@ -47,6 +47,23 @@ export class Domain {
         return this.hypervisor.domainShutdown(this);
     }
 
+    /**
+     * Pauses the domain's execution
+     * @throws {LibvirtError} If pausing the domain fails
+     */
+    async suspend(): Promise<void> {
+        return this.hypervisor.domainSuspend(this);
+    }
+
+    /**
+     * Resumes a paused domain.
+     * This operation restarts execution of a domain that was previously paused.
+     * @throws {LibvirtError} If resuming the domain fails
+     */
+    async resume(): Promise<void> {
+        return this.hypervisor.domainResume(this);
+    }
+
     /**
      * Forcefully terminates the domain.
      * This is equivalent to pulling the power plug on a physical machine.

lib/hypervisor.ts

@@ -180,6 +180,30 @@ export class Hypervisor {
         );
     }
 
+    /**
+     * Pauses a domain.
+     * @param domain - The domain to pause
+     * @throws {LibvirtError} If pausing the domain fails
+     */
+    async domainSuspend(domain: Domain): Promise<void> {
+        return wrapMethod(
+            this.nativeHypervisor.domainSuspend.bind(this.nativeHypervisor),
+            domain.getNativeDomain()
+        );
+    }
+
+    /**
+     * Resumes a paused domain.
+     * @param domain - The domain to resume
+     * @throws {LibvirtError} If resuming the domain fails
+     */
+    async domainResume(domain: Domain): Promise<void> {
+        return wrapMethod(
+            this.nativeHypervisor.domainResume.bind(this.nativeHypervisor),
+            domain.getNativeDomain()
+        );
+    }
+
     /**
      * Forcefully terminates a domain.
      * @param domain - The domain to destroy

scripts/test-docker.sh

@@ -16,55 +16,26 @@ NC='\033[0m' # No Color
 run_tests() {
     local arch=$1
     local tag="libvirt-test-${arch}"
-    local builder_tag="libvirt-builder-${arch}"
 
-    echo -e "${GREEN}Running tests on node:20-slim (${arch})${NC}"
-    
-    # Try to build with caching first
-    if docker buildx build \
-        --platform linux/$arch \
-        --target builder \
-        -t $builder_tag \
-        --cache-from $builder_tag \
-        --cache-to $builder_tag \
+    docker buildx build \
+        --platform linux/"$arch" \
+        -t "$tag" \
         --load \
-        . 2>/dev/null; then
-        
-        # If caching worked, build test stage with cache
-        docker buildx build \
-            --platform linux/$arch \
-            --target test \
-            -t $tag \
-            --cache-from $tag \
-            --cache-to $tag \
-            --load \
-            .
-    else
-        echo -e "${YELLOW}Caching not supported by Docker driver, using simple build${NC}"
-        # Fall back to simple multi-stage build without caching
-        docker buildx build \
-            --platform linux/$arch \
-            --target test \
-            -t $tag \
-            --load \
-            .
-    fi
+        .
+
 
-    # Run the container with necessary privileges
+    # Run the container with necessary privileges and network setup
     docker run --rm \
-        --platform linux/$arch \
+        --platform linux/"$arch" \
         --privileged \
+        --cap-add SYS_ADMIN \
+        --cap-add NET_ADMIN \
+        --device /dev/kvm \
+        --network host \
         -v /var/run/libvirt/libvirt-sock:/var/run/libvirt/libvirt-sock \
         -v /var/lib/libvirt:/var/lib/libvirt \
-        $tag
-    
-    # Check the exit code
-    if [ $? -eq 0 ]; then
-        echo -e "${GREEN}Tests passed on node:20-slim (${arch})${NC}"
-    else
-        echo -e "${RED}Tests failed on node:20-slim (${arch})${NC}"
-        exit 1
-    fi
+        -v /sys/fs/cgroup:/sys/fs/cgroup:ro \
+        "$tag"
 }
 
 # Main script
@@ -76,12 +47,7 @@ if ! docker buildx version >/dev/null 2>&1; then
     docker buildx install
 fi
 
-# Create a temporary directory for test artifacts
-mkdir -p test-artifacts
-
 # Run tests for each architecture
 for arch in "${ARCHES[@]}"; do
     run_tests "$arch"
 done
-
-echo "All tests completed!" 

src/domain.h

@@ -45,6 +45,8 @@ class Domain : public Napi::ObjectWrap<Domain> {
     friend class DomainRestoreWorker;
     friend class DomainGetXMLDescWorker;
     friend class DomainUndefineWorker;
+    friend class DomainSuspendWorker;
+    friend class DomainResumeWorker;
 };
 
 #endif  // SRC_DOMAIN_H_