Overhaul database package

go/buildbot/db.go

 package buildbot
 
 import (
         "database/sql"
         "encoding/json"
         "fmt"
+        "time"
 )
 
 // build from the database.
 func GetCommitsForBuild(master, builder string, buildNumber int) ([]string, error) {
         stmt, err := DB.Preparex(fmt.Sprintf("SELECT revision FROM %s WHERE master = ? AND builder = ? AND number = ?", TABLE_BUILD_REVISIONS))
         if err != nil {
                 return nil, fmt.Errorf("Unable to retrieve build revisions from database - failed to prepare query: %v", err)
         }
         defer stmt.Close()
         commits := []string{}
@@ skipping 67 matching lines @@
         // Get the commits associated with this build.
         build.Commits, err = GetCommitsForBuild(master, builder, buildNumber)
         if err != nil {
                 return nil, fmt.Errorf("Could not retrieve commits for build: %v", err)
         }
 
         return &build, nil
 }
 
 // ReplaceIntoDB inserts or updates the Build in the database.
-func (b Build) ReplaceIntoDB() (rv error) {
+func (b Build) ReplaceIntoDB() error {

[borenet, 2014/12/18 19:12:43]

This increases stability. We occasionally get deadlocks while trying to insert
steps.

+        var err error
+        for attempt := 0; attempt < 5; attempt++ {
+                if err = b.replaceIntoDB(); err == nil {
+                        return nil
+                }
+                time.Sleep(500 * time.Millisecond)
+        }
+        return err
+}
+
+// replaceIntoDB inserts or updates the Build in the database.
+func (b Build) replaceIntoDB() (rv error) {
         // Insert the build itself.
         tx, err := DB.Beginx()
         if err != nil {
                 return fmt.Errorf("Unable to push build into database - Could not begin transaction: %v", err)
         }
         defer func() {
                 if rv != nil {
                         if err := tx.Rollback(); err != nil {
                                 err = fmt.Errorf("Failed to rollback the transaction! %v... Previous error: %v", err, rv)
                         }
@@ skipping 29 matching lines @@
         if err != nil {
                 return fmt.Errorf("Failed to delete build steps from database: %v", err)
         }
         // Actually insert the steps.
         insertStepStmt, err := tx.Preparex(fmt.Sprintf("REPLACE INTO %s (builder,master,buildNumber,name,results,number,started,finished) VALUES (?,?,?,?,?,?,?,?);", TABLE_BUILD_STEPS))
         if err != nil {
                 return fmt.Errorf("Unable to push buildsteps into database - Could not prepare statement: %v", err)
         }
         defer insertStepStmt.Close()
         for _, s := range b.Steps {
-                _, err = insertStepStmt.Exec(s.BuilderName, s.MasterName, s.BuildNumber, s.Name, s.Results, s.Number, s.Started, s.Finished)
+                _, err = insertStepStmt.Exec(b.BuilderName, b.MasterName, b.Number, s.Name, s.Results, s.Number, s.Started, s.Finished)
                 if err != nil {
-                        return fmt.Errorf("Failed to push build into database: %v", err)
+                        return fmt.Errorf("Failed to push build step into database: %v", err)
                 }
 
         }
 
         // Commits.
 
         // First, delete existing revisions so that we don't have leftovers
         // hanging around from before.
         delCmtsStmt, err := tx.Preparex(fmt.Sprintf("DELETE FROM %s WHERE master = ? AND builder = ? AND number = ?;", TABLE_BUILD_REVISIONS))
         if err != nil {
@@ skipping 47 matching lines @@
         if err != nil {
                 return nil, fmt.Errorf("Unable to retrieve unfinished builds - Could not prepare statement: %v", err)
         }
         defer stmt.Close()
         b := []*Build{}
         if err = stmt.Select(&b); err != nil {
                 return nil, fmt.Errorf("Unable to retrieve unfinished builds: %v", err)
         }
         return b, nil
 }