added resuming

Author: oleglazari

Sources/Fuzzilli/Corpus/PostgreSQLCorpus.swift

@@ -25,6 +25,7 @@ public class PostgreSQLCorpus: ComponentBase, Corpus {
     private let databasePool: DatabasePool
     private let fuzzerInstanceId: String
     private let storage: PostgreSQLStorage
+    private let resume: Bool
 
     // MARK: - In-Memory Cache
 
@@ -65,7 +66,8 @@ public class PostgreSQLCorpus: ComponentBase, Corpus {
         minMutationsPerSample: Int,
         databasePool: DatabasePool,
         fuzzerInstanceId: String,
-        syncInterval: TimeInterval = 60.0 // Default 1 minute sync interval
+        syncInterval: TimeInterval = 60.0, // Default 1 minute sync interval
+        resume: Bool = true // Default to resume from previous state
     ) {
         // The corpus must never be empty
         assert(minSize >= 1)
@@ -77,6 +79,7 @@ public class PostgreSQLCorpus: ComponentBase, Corpus {
         self.databasePool = databasePool
         self.fuzzerInstanceId = fuzzerInstanceId
         self.syncInterval = syncInterval
+        self.resume = resume
         self.storage = PostgreSQLStorage(databasePool: databasePool)
 
         self.programs = RingBuffer(maxSize: maxSize)
@@ -176,9 +179,11 @@ public class PostgreSQLCorpus: ComponentBase, Corpus {
             fuzzer.timers.scheduleTask(every: 30 * Minutes, cleanup)
         }
 
-        // Load initial corpus from database
-        Task {
-            await loadInitialCorpus()
+        // Load initial corpus from database if resume is enabled
+        if resume {
+            Task {
+                await loadInitialCorpus()
+            }
         }
     }
 
@@ -423,9 +428,55 @@ public class PostgreSQLCorpus: ComponentBase, Corpus {
     private func loadInitialCorpus() async {
         logger.info("Loading initial corpus from PostgreSQL...")
 
-        // This would be implemented when we have actual database operations
-        // For now, just log that we would load from database
-        logger.info("Initial corpus loading would be implemented here")
+        guard let fuzzerId = fuzzerId else {
+            logger.warning("Cannot load initial corpus: fuzzer not registered")
+            return
+        }
+        
+        do {
+            // Load programs from the last 24 hours to resume recent work
+            let since = Date().addingTimeInterval(-24 * 60 * 60) // 24 hours ago
+            let recentPrograms = try await storage.getRecentPrograms(
+                fuzzerId: fuzzerId, 
+                since: since, 
+                limit: maxSize
+            )
+            
+            logger.info("Found \(recentPrograms.count) recent programs to resume")
+            
+            // Add programs to the corpus
+            cacheLock.lock()
+            defer { cacheLock.unlock() }
+            
+            for (program, metadata) in recentPrograms {
+                let programHash = DatabaseUtils.calculateProgramHash(program: program)
+                
+                // Skip if already in cache
+                if programCache[programHash] != nil {
+                    continue
+                }
+                
+                // Add to in-memory structures
+                prepareProgramForInclusion(program, index: totalEntryCounter)
+                programs.append(program)
+                ages.append(0)
+                programHashes.append(programHash)
+                programCache[programHash] = (program: program, metadata: metadata)
+                
+                totalEntryCounter += 1
+            }
+            
+            logger.info("Resumed PostgreSQL corpus with \(programs.count) programs")
+            
+            // If we have no programs, we need at least one to avoid empty corpus
+            if programs.count == 0 {
+                logger.info("No programs found to resume, corpus will start empty")
+            }
+            
+        } catch {
+            logger.error("Failed to load initial corpus from PostgreSQL: \(error)")
+            logger.info("Corpus will start empty and build up from scratch")
+        }
     }
 
     /// Synchronize with PostgreSQL database
@@ -489,7 +540,8 @@ public class PostgreSQLCorpus: ComponentBase, Corpus {
 
     /// Register fuzzer with retry logic
     private func registerFuzzerWithRetry() async throws -> Int {
-        let fuzzerName = "fuzzer-\(fuzzerInstanceId)"
+        // Use the fuzzerInstanceId directly as the name to avoid double "fuzzer-" prefix
+        let fuzzerName = fuzzerInstanceId
         let engineType = "v8" // This could be made configurable
 
         let maxRetries = 3

Sources/Fuzzilli/Database/DatabaseUtils.swift

@@ -378,6 +378,24 @@ public enum DatabaseUtilsError: Error, LocalizedError {
             return "Invalid metadata format"
         }
     }
+    
+    /// Map execution outcome string to database ID
+    public static func mapExecutionOutcomeFromString(_ outcome: String) -> Int {
+        switch outcome.lowercased() {
+        case "crashed":
+            return 1
+        case "failed":
+            return 2
+        case "succeeded":
+            return 3
+        case "timedout":
+            return 4
+        case "sigcheck":
+            return 34
+        default:
+            return 3 // Default to succeeded
+        }
+    }
 }
 
 // MARK: - Extensions

Sources/Fuzzilli/Database/PostgreSQLStorage.swift

@@ -51,20 +51,42 @@ public class PostgreSQLStorage {
         )
         defer { Task { _ = try? await connection.close() } }
 
-        let query: PostgresQuery = """
+        // First, check if a fuzzer with this name already exists
+        let checkQuery: PostgresQuery = "SELECT fuzzer_id, status FROM main WHERE fuzzer_name = \(name)"
+        let checkResult = try await connection.query(checkQuery, logger: self.logger)
+        let checkRows = try await checkResult.collect()
+        
+        if let existingRow = checkRows.first {
+            let existingFuzzerId = try existingRow.decode(Int.self, context: .default)
+            let existingStatus = try existingRow.decode(String.self, context: .default)
+            
+            // Update status to active if it was inactive
+            if existingStatus != "active" {
+                let updateQuery: PostgresQuery = "UPDATE main SET status = 'active' WHERE fuzzer_id = \(existingFuzzerId)"
+                try await connection.query(updateQuery, logger: self.logger)
+                logger.info("Reactivated existing fuzzer: fuzzerId=\(existingFuzzerId)")
+            } else {
+                logger.info("Reusing existing active fuzzer: fuzzerId=\(existingFuzzerId)")
+            }
+            
+            return existingFuzzerId
+        }
+        
+        // If no existing fuzzer found, create a new one
+        let insertQuery: PostgresQuery = """
             INSERT INTO main (fuzzer_name, engine_type, status) 
             VALUES (\(name), \(engineType), 'active') 
             RETURNING fuzzer_id
         """
 
-        let result = try await connection.query(query, logger: self.logger)
+        let result = try await connection.query(insertQuery, logger: self.logger)
         let rows = try await result.collect()
         guard let row = rows.first else {
             throw PostgreSQLStorageError.noResult
         }
 
         let fuzzerId = try row.decode(Int.self, context: .default)
-        self.logger.info("Fuzzer registration successful: fuzzerId=\(fuzzerId)")
+        self.logger.info("Created new fuzzer: fuzzerId=\(fuzzerId)")
         return fuzzerId
     }
 
@@ -362,10 +384,115 @@ public class PostgreSQLStorage {
     public func getRecentPrograms(fuzzerId: Int, since: Date, limit: Int = 100) async throws -> [(Program, ExecutionMetadata)] {
         logger.info("Getting recent programs: fuzzerId=\(fuzzerId), since=\(since), limit=\(limit)")
 
-        // For now, return empty array
-        // TODO: Implement actual database query when PostgreSQL is set up
-        logger.info("Mock recent programs lookup: no programs found")
-        return []
+        guard let eventLoopGroup = databasePool.getEventLoopGroup() else {
+            throw PostgreSQLStorageError.noResult
+        }
+        
+        let connection = try await PostgresConnection.connect(
+            on: eventLoopGroup.next(),
+            configuration: PostgresConnection.Configuration(
+                host: "localhost",
+                port: 5433,
+                username: "fuzzilli",
+                password: "fuzzilli123",
+                database: "fuzzilli",
+                tls: .disable
+            ),
+            id: 0,
+            logger: logger
+        )
+        defer { Task { _ = try? await connection.close() } }
+        
+        // Query for recent programs with their latest execution metadata
+        let queryString = """
+            SELECT 
+                p.program_base64,
+                p.program_size,
+                p.program_hash,
+                p.created_at,
+                eo.outcome,
+                eo.description,
+                e.execution_time_ms,
+                e.coverage_total,
+                e.signal_code,
+                e.exit_code
+            FROM program p
+            LEFT JOIN execution e ON p.program_base64 = e.program_base64
+            LEFT JOIN execution_outcome eo ON e.execution_outcome_id = eo.id
+            WHERE p.fuzzer_id = \(fuzzerId)
+            AND p.created_at >= '\(since.ISO8601Format())'
+            ORDER BY p.created_at DESC
+            LIMIT \(limit)
+        """
+        
+        let query = PostgresQuery(stringLiteral: queryString)
+        let result = try await connection.query(query, logger: self.logger)
+        let rows = try await result.collect()
+        
+        var programs: [(Program, ExecutionMetadata)] = []
+        
+        for row in rows {
+            let programBase64 = try row.decode(String.self, context: .default)
+            let programSize = try row.decode(Int.self, context: .default)
+            let programHash = try row.decode(String.self, context: .default)
+            let createdAt = try row.decode(Date.self, context: .default)
+            let outcome = try row.decode(String?.self, context: .default)
+            let description = try row.decode(String?.self, context: .default)
+            let executionTimeMs = try row.decode(Int?.self, context: .default)
+            let coverageTotal = try row.decode(Double?.self, context: .default)
+            let signalCode = try row.decode(Int?.self, context: .default)
+            let exitCode = try row.decode(Int?.self, context: .default)
+            
+            // Decode the program from base64
+            guard let programData = Data(base64Encoded: programBase64) else {
+                logger.warning("Failed to decode base64 data for program: \(programHash)")
+                continue
+            }
+            
+            let program: Program
+            do {
+                let protobuf = try Fuzzilli_Protobuf_Program(serializedBytes: programData)
+                program = try Program(from: protobuf)
+            } catch {
+                logger.warning("Failed to decode program from protobuf: \(programHash), error: \(error)")
+                continue
+            }
+            
+            // Create execution metadata
+            
+            // Map outcome string to database ID
+            let outcomeId: Int
+            switch (outcome ?? "Succeeded").lowercased() {
+            case "crashed":
+                outcomeId = 1
+            case "failed":
+                outcomeId = 2
+            case "succeeded":
+                outcomeId = 3
+            case "timedout":
+                outcomeId = 4
+            case "sigcheck":
+                outcomeId = 34
+            default:
+                outcomeId = 3 // Default to succeeded
+            }
+            
+            let dbOutcome = DatabaseExecutionOutcome(
+                id: outcomeId,
+                outcome: outcome ?? "Succeeded",
+                description: description ?? "Program executed successfully"
+            )
+            
+            var metadata = ExecutionMetadata(lastOutcome: dbOutcome)
+            if let coverage = coverageTotal {
+                metadata.lastCoverage = coverage
+            }
+            
+            programs.append((program, metadata))
+        }
+        
+        logger.info("Loaded \(programs.count) recent programs from database")
+        return programs
     }
 
     /// Update program metadata

Sources/FuzzilliCli/main.swift

@@ -518,7 +518,8 @@ func makeFuzzer(with configuration: Configuration) -> Fuzzer {
         }
 
         let databasePool = DatabasePool(connectionString: postgresUrl)
-        let fuzzerInstanceId = "fuzzer-\(UUID().uuidString.prefix(8))"
+        // Use a consistent fuzzer instance ID so we can resume with the same fuzzer
+        let fuzzerInstanceId = "fuzzer-main"
 
         corpus = PostgreSQLCorpus(
             minSize: minCorpusSize,