webtry: Do not forget the close the rows.

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/binary"
         "encoding/json"
         "flag"
@@ skipping 285 matching lines @@
         // like the IP address of the Graphite monitor.
         addr, _ := net.ResolveTCPAddr("tcp", "skia-monitoring-b:2003")
         go metrics.Graphite(metrics.DefaultRegistry, 1*time.Minute, "webtry", addr)
 
         writeOutAllSourceImages()
 }
 
 func writeOutAllSourceImages() {
         // Pull all the source images from the db and write them out to inout.
         rows, err := db.Query("SELECT id, image, create_ts FROM source_images ORDER BY create_ts DESC")
-
         if err != nil {
                 glog.Errorf("Failed to open connection to SQL server: %q\n", err)
                 panic(err)
         }
+        defer rows.Close()
         for rows.Next() {
                 var id int
                 var image []byte
                 var create_ts time.Time
                 if err := rows.Scan(&id, &image, &create_ts); err != nil {
                         glog.Errorf("failed to fetch from database: %q", err)
                         continue
                 }
                 filename := fmt.Sprintf("../../../inout/image-%d.png", id)
                 if _, err := os.Stat(filename); os.IsExist(err) {
@@ skipping 150 matching lines @@
 
 type Sources struct {
         Id int `json:"id"`
 }
 
 // sourcesHandler serves up the PNG of a specific try.
 func sourcesHandler(w http.ResponseWriter, r *http.Request) {
         glog.Infof("Sources Handler: %q\n", r.URL.Path)
         if r.Method == "GET" {
                 rows, err := db.Query("SELECT id, create_ts FROM source_images WHERE hidden=0 ORDER BY create_ts DESC")
-
                 if err != nil {
                         http.Error(w, fmt.Sprintf("Failed to query sources: %s.", err), 500)
                 }
+                defer rows.Close()
                 sources := make([]Sources, 0, 0)
                 for rows.Next() {
                         var id int
                         var create_ts time.Time
                         if err := rows.Scan(&id, &create_ts); err != nil {
                                 glog.Errorf("failed to fetch from database: %q", err)
                                 continue
                         }
                         sources = append(sources, Sources{Id: id})
                 }
@@ skipping 75 matching lines @@
 
 type Recent struct {
         Tries    []Try
         Titlebar Titlebar
 }
 
 // recentHandler shows the last 20 tries.
 func recentHandler(w http.ResponseWriter, r *http.Request) {
         glog.Infof("Recent Handler: %q\n", r.URL.Path)
 
-        var err error
         rows, err := db.Query("SELECT create_ts, hash FROM webtry ORDER BY create_ts DESC LIMIT 20")
         if err != nil {
                 http.NotFound(w, r)
                 return
         }
+        defer rows.Close()
         recent := []Try{}
         for rows.Next() {
                 var hash string
                 var create_ts time.Time
                 if err := rows.Scan(&create_ts, &hash); err != nil {
                         glog.Errorf("failed to fetch from database: %q", err)
                         continue
                 }
                 recent = append(recent, Try{Hash: hash, CreateTS: create_ts.Format("2006-02-01")})
         }
@@ skipping 51 matching lines @@
                 tries := []Try{}
                 match := workspaceLink.FindStringSubmatch(r.URL.Path)
                 name := ""
                 if len(match) == 2 {
                         name = match[1]
                         rows, err := db.Query("SELECT create_ts, hash, source_image_id FROM workspacetry WHERE name=? ORDER BY create_ts", name)
                         if err != nil {
                                 reportError(w, r, err, "Failed to select.")
                                 return
                         }
+                        defer rows.Close()
                         for rows.Next() {
                                 var hash string
                                 var create_ts time.Time
                                 var source int
                                 if err := rows.Scan(&create_ts, &hash, &source); err != nil {
                                         glog.Errorf("failed to fetch from database: %q", err)
                                         continue
                                 }
                                 tries = append(tries, Try{Hash: hash, Source: source, CreateTS: create_ts.Format("2006-02-01")})
                         }
@@ skipping 236 matching lines @@
         http.HandleFunc("/sources/", autogzip.HandleFunc(sourcesHandler))
 
         // Resources are served directly
         // TODO add support for caching/etags/gzip
         http.Handle("/res/", autogzip.Handle(http.FileServer(http.Dir("./"))))
 
         // TODO Break out /c/ as it's own handler.
         http.HandleFunc("/", autogzip.HandleFunc(mainHandler))
         glog.Fatal(http.ListenAndServe(*port, nil))
 }