Use loggo for logging
authorJan Dittberner <jan@dittberner.info>
Fri, 21 Apr 2017 22:06:16 +0000 (00:06 +0200)
committerJan Dittberner <jan@dittberner.info>
Fri, 21 Apr 2017 22:14:38 +0000 (00:14 +0200)
boardvoting.go
jobs.go
models.go
notifications.go

index 539013a..1e62908 100644 (file)
@@ -11,23 +11,22 @@ import (
        "github.com/Masterminds/sprig"
        "github.com/gorilla/sessions"
        "github.com/jmoiron/sqlx"
+       "github.com/juju/loggo"
        _ "github.com/mattn/go-sqlite3"
        "gopkg.in/yaml.v2"
        "html/template"
        "io/ioutil"
-       "log"
        "net/http"
-       "os"
        "strconv"
        "strings"
        "time"
 )
 
-var logger *log.Logger
 var config *Config
 var store *sessions.CookieStore
 var version = "undefined"
 var build = "undefined"
+var logger loggo.Logger
 
 const sessionCookieName = "votesession"
 
@@ -243,13 +242,13 @@ type FlashMessageAction struct{}
 func (a *FlashMessageAction) AddFlash(w http.ResponseWriter, r *http.Request, message interface{}, tags ...string) (err error) {
        session, err := store.Get(r, sessionCookieName)
        if err != nil {
-               logger.Println("ERROR getting session:", err)
+               logger.Errorf("getting session failed: %s", err)
                return
        }
        session.AddFlash(message, tags...)
        session.Save(r, w)
        if err != nil {
-               logger.Println("ERROR saving session:", err)
+               logger.Errorf("saving session failed: %s", err)
                return
        }
        return
@@ -283,7 +282,7 @@ func (a *withDrawMotionAction) Handle(w http.ResponseWriter, r *http.Request) {
                decision.Status = voteStatusWithdrawn
                decision.Modified = time.Now().UTC()
                if err := decision.UpdateStatus(); err != nil {
-                       logger.Println("Error withdrawing motion:", err)
+                       logger.Errorf("withdrawing motion failed: %s", err)
                        http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
                        return
                }
@@ -336,7 +335,7 @@ func (h *newMotionHandler) Handle(w http.ResponseWriter, r *http.Request) {
                        data.Proposed = time.Now().UTC()
                        data.ProponentId = voter.Id
                        if err := data.Create(); err != nil {
-                               logger.Println("Error saving motion:", err)
+                               logger.Errorf("saving motion failed: %s", err)
                                http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
                                return
                        }
@@ -401,7 +400,7 @@ func (a editMotionAction) Handle(w http.ResponseWriter, r *http.Request) {
                } else {
                        data.Modified = time.Now().UTC()
                        if err := data.Update(); err != nil {
-                               logger.Println("Error updating motion:", err)
+                               logger.Errorf("updating motion failed: %s", err)
                                http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
                                return
                        }
@@ -431,10 +430,6 @@ func (a editMotionAction) Handle(w http.ResponseWriter, r *http.Request) {
 type motionsHandler struct{}
 
 func (h motionsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-       if err := db.Ping(); err != nil {
-               logger.Fatal(err)
-       }
-
        subURL := r.URL.Path
 
        var motionActionMap = map[string]motionActionHandler{
@@ -505,7 +500,7 @@ func (h *directVoteHandler) Handle(w http.ResponseWriter, r *http.Request) {
                        VoterId: voter.Id, Vote: vote, DecisionId: decision.Id, Voted: time.Now().UTC(),
                        Notes: fmt.Sprintf("Direct Vote\n\n%s", getPEMClientCert(r))}
                if err := voteResult.Save(); err != nil {
-                       logger.Println("ERROR", "Problem saving vote:", err)
+                       logger.Errorf("Problem saving vote: %s", err)
                        http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
                        return
                }
@@ -589,7 +584,7 @@ func (h *proxyVoteHandler) Handle(w http.ResponseWriter, r *http.Request) {
                                proxy.Name, justification, getPEMClientCert(r))
 
                        if err := data.Save(); err != nil {
-                               logger.Println("Error saving vote:", err)
+                               logger.Errorf("Error saving vote: %s", err)
                                http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
                                return
                        }
@@ -620,10 +615,6 @@ func (h *proxyVoteHandler) Handle(w http.ResponseWriter, r *http.Request) {
 type decisionVoteHandler struct{}
 
 func (h *decisionVoteHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-       if err := db.Ping(); err != nil {
-               logger.Fatal(err)
-       }
-
        switch {
        case strings.HasPrefix(r.URL.Path, "/proxy/"):
                motionTag := r.URL.Path[len("/proxy/"):]
@@ -675,35 +666,42 @@ type Config struct {
 }
 
 func init() {
-       logger = log.New(os.Stderr, "boardvoting: ", log.LstdFlags|log.LUTC|log.Lshortfile)
+       loggo.ConfigureLoggers("<root>=ERROR; boardvoting=INFO")
+       logger = loggo.GetLogger("boardvoting")
+       logger.Infof("Logger initialized")
 
        source, err := ioutil.ReadFile("config.yaml")
        if err != nil {
-               logger.Fatal(err)
+               logger.Criticalf("Opening configuration file failed: %s", err)
+               panic(err)
        }
        if err := yaml.Unmarshal(source, &config); err != nil {
-               logger.Fatal(err)
+               logger.Criticalf("Loading configuration failed: %s", err)
+               panic(err)
        }
 
        cookieSecret, err := base64.StdEncoding.DecodeString(config.CookieSecret)
        if err != nil {
-               logger.Fatal(err)
+               logger.Criticalf("Decoding cookie secret failed: %s", err)
+               panic(err)
        }
        if len(cookieSecret) < 32 {
-               logger.Fatalln("Cookie secret is less than 32 bytes long")
+               logger.Criticalf("Cookie secret is less than 32 bytes long")
+               panic("Cookie secret too short")
        }
        store = sessions.NewCookieStore(cookieSecret)
-       logger.Println("read configuration")
+       logger.Infof("Read configuration")
 
        db, err = sqlx.Open("sqlite3", config.DatabaseFile)
        if err != nil {
-               logger.Fatal(err)
+               logger.Criticalf("Opening database failed: %s", err)
+               panic(err)
        }
-       logger.Println("opened database connection")
+       logger.Infof("opened database connection")
 }
 
 func main() {
-       logger.Printf("CAcert Board Voting version %s, build %s\n", version, build)
+       logger.Infof("CAcert Board Voting version %s, build %s", version, build)
 
        defer db.Close()
 
@@ -725,11 +723,13 @@ func main() {
        // load CA certificates for client authentication
        caCert, err := ioutil.ReadFile(config.ClientCACertificates)
        if err != nil {
-               logger.Fatal(err)
+               logger.Criticalf("Error reading client certificate CAs", err)
+               panic(err)
        }
        caCertPool := x509.NewCertPool()
        if !caCertPool.AppendCertsFromPEM(caCert) {
-               logger.Fatal("could not initialize client CA certificate pool")
+               logger.Criticalf("could not initialize client CA certificate pool")
+               panic("client certificate CA pool initialization failed")
        }
 
        // setup HTTPS server
@@ -744,7 +744,7 @@ func main() {
                TLSConfig: tlsConfig,
        }
 
-       logger.Printf("Launching application on https://localhost%s/\n", server.Addr)
+       logger.Infof("Launching application on https://localhost%s/", server.Addr)
 
        errs := make(chan error, 1)
        go func() {
@@ -755,9 +755,11 @@ func main() {
        }()
 
        if err = server.ListenAndServeTLS(config.ServerCert, config.ServerKey); err != nil {
-               logger.Fatal("ListenAndServerTLS: ", err)
+               logger.Criticalf("ListenAndServerTLS failed: %s", err)
+               panic(err)
        }
        if err := <-errs; err != nil {
-               logger.Fatal("ListenAndServe: ", err)
+               logger.Criticalf("ListenAndServe failed: %s", err)
+               panic(err)
        }
 }
diff --git a/jobs.go b/jobs.go
index 2535ef1..8d0bf13 100644 (file)
--- a/jobs.go
+++ b/jobs.go
@@ -22,19 +22,19 @@ func JobScheduler(quitChannel chan int) {
                JobIdCloseDecisions:  NewCloseDecisionsJob(),
                JobIdRemindVotersJob: NewRemindVotersJob(),
        }
-       logger.Println("INFO started job scheduler")
+       logger.Infof("started job scheduler")
 
        for {
                select {
                case jobId := <-rescheduleChannel:
                        job := jobs[jobId]
-                       logger.Println("INFO reschedule job", job)
+                       logger.Infof("reschedule job %s", job)
                        job.Schedule()
                case <-quitChannel:
                        for _, job := range jobs {
                                job.Stop()
                        }
-                       logger.Println("INFO stop job scheduler")
+                       logger.Infof("stop job scheduler")
                        return
                }
        }
@@ -54,7 +54,7 @@ func (j *CloseDecisionsJob) Schedule() {
        var nextDue *time.Time
        nextDue, err := GetNextPendingDecisionDue()
        if err != nil {
-               logger.Fatal("ERROR Could not get next pending due date")
+               logger.Errorf("Could not get next pending due date")
                if j.timer != nil {
                        j.timer.Stop()
                        j.timer = nil
@@ -62,11 +62,11 @@ func (j *CloseDecisionsJob) Schedule() {
                return
        }
        if nextDue == nil {
-               logger.Println("INFO no next planned execution of CloseDecisionsJob")
+               logger.Infof("no next planned execution of CloseDecisionsJob")
                j.Stop()
        } else {
                nextDue := nextDue.Add(time.Minute)
-               logger.Println("INFO scheduling CloseDecisionsJob for", nextDue)
+               logger.Infof("scheduling CloseDecisionsJob for %s", nextDue)
                when := nextDue.Sub(time.Now())
                if j.timer != nil {
                        j.timer.Reset(when)
@@ -84,10 +84,10 @@ func (j *CloseDecisionsJob) Stop() {
 }
 
 func (j *CloseDecisionsJob) Run() {
-       logger.Println("INFO running CloseDecisionsJob")
+       logger.Infof("running CloseDecisionsJob")
        err := CloseDecisions()
        if err != nil {
-               logger.Println("ERROR closing decisions", err)
+               logger.Errorf("closing decisions %s", err)
        }
        rescheduleChannel <- JobIdCloseDecisions
 }
@@ -109,7 +109,7 @@ func NewRemindVotersJob() *RemindVotersJob {
 func (j *RemindVotersJob) Schedule() {
        year, month, day := time.Now().UTC().Date()
        nextExecution := time.Date(year, month, day, 0, 0, 0, 0, time.UTC).AddDate(0, 0, 3)
-       logger.Println("INFO scheduling RemindVotersJob for", nextExecution)
+       logger.Infof("scheduling RemindVotersJob for %s", nextExecution)
        when := nextExecution.Sub(time.Now())
        if j.timer != nil {
                j.timer.Reset(when)
@@ -126,19 +126,19 @@ func (j *RemindVotersJob) Stop() {
 }
 
 func (j *RemindVotersJob) Run() {
-       logger.Println("INFO running RemindVotersJob")
+       logger.Infof("running RemindVotersJob")
        defer func() { rescheduleChannel <- JobIdRemindVotersJob }()
 
        voters, err := GetReminderVoters()
        if err != nil {
-               logger.Println("ERROR problem getting voters", err)
+               logger.Errorf("problem getting voters %s", err)
                return
        }
 
        for _, voter := range *voters {
                decisions, err := FindUnvotedDecisionsForVoter(&voter)
                if err != nil {
-                       logger.Println("ERROR problem getting unvoted decisions")
+                       logger.Errorf("problem getting unvoted decisions")
                        return
                }
                if len(*decisions) > 0 {
index f6dc884..35511ed 100644 (file)
--- a/models.go
+++ b/models.go
@@ -126,14 +126,19 @@ WHERE  decision=$1 AND voter=$2`,
 var db *sqlx.DB
 
 func init() {
+       failed_statements := make([]string, 0)
        for _, sqlStatement := range sqlStatements {
                var stmt *sqlx.Stmt
                stmt, err := db.Preparex(sqlStatement)
                if err != nil {
-                       logger.Fatalf("ERROR parsing statement %s: %s", sqlStatement, err)
+                       logger.Criticalf("ERROR parsing statement %s: %s", sqlStatement, err)
+                       failed_statements = append(failed_statements, sqlStatement)
                }
                stmt.Close()
        }
+       if len(failed_statements) > 0 {
+               panic(fmt.Sprintf("%d statements failed", len(failed_statements)))
+       }
 
        migrateConf := &goose.DBConf{
                MigrationsDir: config.MigrationsPath,
@@ -148,12 +153,14 @@ func init() {
 
        latest, err := goose.GetMostRecentDBVersion(migrateConf.MigrationsDir)
        if err != nil {
-               logger.Panicln(err)
+               logger.Criticalf("getting the most recent database repository version failed: %s", err)
+               panic(err)
        }
 
        err = goose.RunMigrationsOnDb(migrateConf, migrateConf.MigrationsDir, latest, db.DB)
        if err != nil {
-               logger.Panicln(err)
+               logger.Criticalf("running database migration failed: %s", err)
+               panic(err)
        }
 }
 
@@ -278,27 +285,27 @@ type Vote struct {
 func (v *Vote) Save() (err error) {
        insertVoteStmt, err := db.PrepareNamed(sqlStatements[sqlCreateVote])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer insertVoteStmt.Close()
 
        _, err = insertVoteStmt.Exec(v)
        if err != nil {
-               logger.Println("Error saving vote:", err)
+               logger.Errorf("saving vote failed: %s", err)
                return
        }
 
        getVoteStmt, err := db.Preparex(sqlStatements[sqlLoadVote])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer getVoteStmt.Close()
 
        err = getVoteStmt.Get(v, v.DecisionId, v.VoterId)
        if err != nil {
-               logger.Println("Error getting inserted vote:", err)
+               logger.Errorf("getting inserted vote failed: %s", err)
        }
 
        return
@@ -341,7 +348,7 @@ type DecisionForDisplay struct {
 func FindDecisionForDisplayByTag(tag string) (decision *DecisionForDisplay, err error) {
        decisionStmt, err := db.Preparex(sqlStatements[sqlLoadDecisionByTag])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer decisionStmt.Close()
@@ -352,7 +359,7 @@ func FindDecisionForDisplayByTag(tag string) (decision *DecisionForDisplay, err
                        decision = nil
                        err = nil
                } else {
-                       logger.Printf("Error getting motion %s: %v\n", tag, err)
+                       logger.Errorf("getting motion %s failed: %v", tag, err)
                }
        }
        decision.VoteSums, err = decision.Decision.VoteSums()
@@ -372,7 +379,7 @@ func FindDecisionsForDisplayOnPage(page int64, unvoted bool, voter *Voter) (deci
                decisionsStmt, err = db.Preparex(sqlStatements[sqlLoadDecisions])
        }
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer decisionsStmt.Close()
@@ -384,7 +391,7 @@ func FindDecisionsForDisplayOnPage(page int64, unvoted bool, voter *Voter) (deci
                rows, err = decisionsStmt.Queryx(page - 1)
        }
        if err != nil {
-               logger.Printf("Error loading motions for page %d: %v\n", page, err)
+               logger.Errorf("loading motions for page %d failed: %v", page, err)
                return
        }
        defer rows.Close()
@@ -392,7 +399,7 @@ func FindDecisionsForDisplayOnPage(page int64, unvoted bool, voter *Voter) (deci
        for rows.Next() {
                var d DecisionForDisplay
                if err = rows.StructScan(&d); err != nil {
-                       logger.Printf("Error loading motions for page %d: %v\n", page, err)
+                       logger.Errorf("loading motions for page %d failed: %v", page, err)
                        return
                }
                d.VoteSums, err = d.Decision.VoteSums()
@@ -407,14 +414,14 @@ func FindDecisionsForDisplayOnPage(page int64, unvoted bool, voter *Voter) (deci
 func (d *Decision) VoteSums() (sums *VoteSums, err error) {
        votesStmt, err := db.Preparex(sqlStatements[sqlLoadVoteCountsForDecision])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer votesStmt.Close()
 
        voteRows, err := votesStmt.Queryx(d.Id)
        if err != nil {
-               logger.Printf("Error fetching vote sums for motion %s: %v\n", d.Tag, err)
+               logger.Errorf("fetching vote sums for motion %s failed: %v", d.Tag, err)
                return
        }
        defer voteRows.Close()
@@ -424,7 +431,7 @@ func (d *Decision) VoteSums() (sums *VoteSums, err error) {
                var vote VoteChoice
                var count int
                if err = voteRows.Scan(&vote, &count); err != nil {
-                       logger.Printf("Error fetching vote sums for motion %s: %v\n", d.Tag, err)
+                       logger.Errorf("fetching vote sums for motion %s failed: %v", d.Tag, err)
                        return
                }
                switch vote {
@@ -442,13 +449,13 @@ func (d *Decision) VoteSums() (sums *VoteSums, err error) {
 func (d *DecisionForDisplay) LoadVotes() (err error) {
        votesStmt, err := db.Preparex(sqlStatements[sqlLoadVotesForDecision])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer votesStmt.Close()
        err = votesStmt.Select(&d.Votes, d.Id)
        if err != nil {
-               logger.Printf("Error selecting votes for motion %s: %v\n", d.Tag, err)
+               logger.Errorf("selecting votes for motion %s failed: %v", d.Tag, err)
        }
        return
 }
@@ -461,18 +468,18 @@ func (d *Decision) OlderExists(unvoted bool, voter *Voter) (result bool, err err
                olderStmt, err = db.Preparex(sqlStatements[sqlCountOlderThanDecision])
        }
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer olderStmt.Close()
 
        if unvoted && voter != nil {
                if err = olderStmt.Get(&result, d.Proposed, voter.Id); err != nil {
-                       logger.Printf("Error finding older motions than %s: %v\n", d.Tag, err)
+                       logger.Errorf("finding older motions than %s failed: %v", d.Tag, err)
                }
        } else {
                if err = olderStmt.Get(&result, d.Proposed); err != nil {
-                       logger.Printf("Error finding older motions than %s: %v\n", d.Tag, err)
+                       logger.Errorf("finding older motions than %s failed: %v", d.Tag, err)
                }
        }
 
@@ -482,34 +489,34 @@ func (d *Decision) OlderExists(unvoted bool, voter *Voter) (result bool, err err
 func (d *Decision) Create() (err error) {
        insertDecisionStmt, err := db.PrepareNamed(sqlStatements[sqlCreateDecision])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer insertDecisionStmt.Close()
 
        result, err := insertDecisionStmt.Exec(d)
        if err != nil {
-               logger.Println("Error creating motion:", err)
+               logger.Errorf("creating motion failed: %s", err)
                return
        }
 
        lastInsertId, err := result.LastInsertId()
        if err != nil {
-               logger.Println("Error getting id of inserted motion:", err)
+               logger.Errorf("getting id of inserted motion failed: %s", err)
                return
        }
        rescheduleChannel <- JobIdCloseDecisions
 
        getDecisionStmt, err := db.Preparex(sqlStatements[sqlLoadDecisionById])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer getDecisionStmt.Close()
 
        err = getDecisionStmt.Get(d, lastInsertId)
        if err != nil {
-               logger.Println("Error getting inserted motion:", err)
+               logger.Errorf("getting inserted motion failed: %s", err)
        }
 
        return
@@ -518,14 +525,14 @@ func (d *Decision) Create() (err error) {
 func (d *Decision) LoadWithId() (err error) {
        getDecisionStmt, err := db.Preparex(sqlStatements[sqlLoadDecisionById])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer getDecisionStmt.Close()
 
        err = getDecisionStmt.Get(d, d.Id)
        if err != nil {
-               logger.Println("Error loading updated motion:", err)
+               logger.Errorf("loading updated motion failed: %s", err)
        }
 
        return
@@ -534,22 +541,22 @@ func (d *Decision) LoadWithId() (err error) {
 func (d *Decision) Update() (err error) {
        updateDecisionStmt, err := db.PrepareNamed(sqlStatements[sqlUpdateDecision])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer updateDecisionStmt.Close()
 
        result, err := updateDecisionStmt.Exec(d)
        if err != nil {
-               logger.Println("Error updating motion:", err)
+               logger.Errorf("updating motion failed: %s", err)
                return
        }
        affectedRows, err := result.RowsAffected()
        if err != nil {
-               logger.Print("Problem determining the affected rows")
+               logger.Errorf("Problem determining the affected rows")
                return
        } else if affectedRows != 1 {
-               logger.Printf("WARNING wrong number of affected rows: %d (1 expected)\n", affectedRows)
+               logger.Warningf("wrong number of affected rows: %d (1 expected)", affectedRows)
        }
        rescheduleChannel <- JobIdCloseDecisions
 
@@ -560,22 +567,22 @@ func (d *Decision) Update() (err error) {
 func (d *Decision) UpdateStatus() (err error) {
        updateStatusStmt, err := db.PrepareNamed(sqlStatements[sqlUpdateDecisionStatus])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer updateStatusStmt.Close()
 
        result, err := updateStatusStmt.Exec(d)
        if err != nil {
-               logger.Println("Error setting motion status:", err)
+               logger.Errorf("setting motion status failed: %s", err)
                return
        }
        affectedRows, err := result.RowsAffected()
        if err != nil {
-               logger.Print("Problem determining the affected rows")
+               logger.Errorf("determining the affected rows failed: %s", err)
                return
        } else if affectedRows != 1 {
-               logger.Printf("WARNING wrong number of affected rows: %d (1 expected)\n", affectedRows)
+               logger.Warningf("wrong number of affected rows: %d (1 expected)", affectedRows)
        }
        rescheduleChannel <- JobIdCloseDecisions
 
@@ -590,7 +597,7 @@ func (d *Decision) String() string {
 func FindVoterByAddress(emailAddress string) (voter *Voter, err error) {
        findVoterStmt, err := db.Preparex(sqlStatements[sqlLoadEnabledVoterByEmail])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer findVoterStmt.Close()
@@ -598,7 +605,7 @@ func FindVoterByAddress(emailAddress string) (voter *Voter, err error) {
        voter = &Voter{}
        if err = findVoterStmt.Get(voter, emailAddress); err != nil {
                if err != sql.ErrNoRows {
-                       logger.Printf("Error getting voter for address %s: %v\n", emailAddress, err)
+                       logger.Errorf("getting voter for address %s failed: %v", emailAddress, err)
                } else {
                        err = nil
                        voter = nil
@@ -613,7 +620,7 @@ func (d *Decision) Close() (err error) {
        voteSums, err := d.VoteSums()
 
        if err != nil {
-               logger.Println("Error getting vote sums")
+               logger.Errorf("getting vote sums failed: %s", err)
                return
        }
        votes := voteSums.VoteCount()
@@ -631,22 +638,22 @@ func (d *Decision) Close() (err error) {
 
        closeDecisionStmt, err := db.PrepareNamed(sqlStatements[sqlUpdateDecisionStatus])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer closeDecisionStmt.Close()
 
        result, err := closeDecisionStmt.Exec(d)
        if err != nil {
-               logger.Println("Error closing vote:", err)
+               logger.Errorf("closing vote failed: %s", err)
                return
        }
        affectedRows, err := result.RowsAffected()
        if err != nil {
-               logger.Println("Error getting affected rows:", err)
+               logger.Errorf("getting affected rows failed: %s", err)
        }
        if affectedRows != 1 {
-               logger.Printf("WARNING wrong number of affected rows: %d (1 expected)\n", affectedRows)
+               logger.Warningf("wrong number of affected rows: %d (1 expected)", affectedRows)
        }
 
        NotifyMailChannel <- NewNotificationClosedDecision(d, voteSums)
@@ -657,7 +664,7 @@ func (d *Decision) Close() (err error) {
 func CloseDecisions() (err error) {
        getClosableDecisionsStmt, err := db.PrepareNamed(sqlStatements[sqlSelectClosableDecisions])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer getClosableDecisionsStmt.Close()
@@ -665,14 +672,14 @@ func CloseDecisions() (err error) {
        decisions := make([]*Decision, 0)
        rows, err := getClosableDecisionsStmt.Queryx(struct{ Now time.Time }{time.Now().UTC()})
        if err != nil {
-               logger.Println("Error fetching closable decisions", err)
+               logger.Errorf("fetching closable decisions failed: %s", err)
                return
        }
        defer rows.Close()
        for rows.Next() {
                decision := &Decision{}
                if err = rows.StructScan(decision); err != nil {
-                       logger.Println("Error scanning row", err)
+                       logger.Errorf("scanning row failed: %s", err)
                        return
                }
                decisions = append(decisions, decision)
@@ -680,9 +687,9 @@ func CloseDecisions() (err error) {
        rows.Close()
 
        for _, decision := range decisions {
-               logger.Println("DEBUG found closable decision", decision)
+               logger.Debugf("found closable decision %s", decision.Tag)
                if err = decision.Close(); err != nil {
-                       logger.Printf("Error closing decision %s: %s\n", decision, err)
+                       logger.Errorf("closing decision %s failed: %s", decision.Tag, err)
                        return
                }
        }
@@ -693,7 +700,7 @@ func CloseDecisions() (err error) {
 func GetNextPendingDecisionDue() (due *time.Time, err error) {
        getNextPendingDecisionDueStmt, err := db.Preparex(sqlStatements[sqlGetNextPendingDecisionDue])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer getNextPendingDecisionDueStmt.Close()
@@ -703,10 +710,10 @@ func GetNextPendingDecisionDue() (due *time.Time, err error) {
        var dueTimestamp time.Time
        if err = row.Scan(&dueTimestamp); err != nil {
                if err == sql.ErrNoRows {
-                       logger.Println("DEBUG No pending decisions")
+                       logger.Debugf("No pending decisions")
                        return nil, nil
                }
-               logger.Println("Error parsing result", err)
+               logger.Errorf("parsing result failed: %s", err)
                return
        }
        due = &dueTimestamp
@@ -717,7 +724,7 @@ func GetNextPendingDecisionDue() (due *time.Time, err error) {
 func GetReminderVoters() (voters *[]Voter, err error) {
        getReminderVotersStmt, err := db.Preparex(sqlStatements[sqlGetReminderVoters])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer getReminderVotersStmt.Close()
@@ -725,7 +732,7 @@ func GetReminderVoters() (voters *[]Voter, err error) {
        voterSlice := make([]Voter, 0)
 
        if err = getReminderVotersStmt.Select(&voterSlice); err != nil {
-               logger.Println("Error getting voters:", err)
+               logger.Errorf("getting voters failed: %s", err)
                return
        }
        voters = &voterSlice
@@ -736,7 +743,7 @@ func GetReminderVoters() (voters *[]Voter, err error) {
 func FindUnvotedDecisionsForVoter(voter *Voter) (decisions *[]Decision, err error) {
        findUnvotedDecisionsForVoterStmt, err := db.Preparex(sqlStatements[sqlFindUnvotedDecisionsForVoter])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer findUnvotedDecisionsForVoterStmt.Close()
@@ -744,7 +751,7 @@ func FindUnvotedDecisionsForVoter(voter *Voter) (decisions *[]Decision, err erro
        decisionsSlice := make([]Decision, 0)
 
        if err = findUnvotedDecisionsForVoterStmt.Select(&decisionsSlice, voter.Id); err != nil {
-               logger.Println("Error getting unvoted decisions:", err)
+               logger.Errorf("getting unvoted decisions failed: %s", err)
                return
        }
        decisions = &decisionsSlice
@@ -755,14 +762,14 @@ func FindUnvotedDecisionsForVoter(voter *Voter) (decisions *[]Decision, err erro
 func GetVoterById(id int64) (voter *Voter, err error) {
        getVoterByIdStmt, err := db.Preparex(sqlStatements[sqlGetEnabledVoterById])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer getVoterByIdStmt.Close()
 
        voter = &Voter{}
        if err = getVoterByIdStmt.Get(voter, id); err != nil {
-               logger.Println("Error getting voter:", err)
+               logger.Errorf("getting voter failed: %s", err)
                return
        }
 
@@ -772,7 +779,7 @@ func GetVoterById(id int64) (voter *Voter, err error) {
 func GetVotersForProxy(proxy *Voter, decision *Decision) (voters *[]Voter, err error) {
        getVotersForProxyStmt, err := db.Preparex(sqlStatements[sqlGetVotersForProxy])
        if err != nil {
-               logger.Println("Error preparing statement:", err)
+               logger.Errorf("preparing statement failed: %s", err)
                return
        }
        defer getVotersForProxyStmt.Close()
@@ -780,7 +787,7 @@ func GetVotersForProxy(proxy *Voter, decision *Decision) (voters *[]Voter, err e
        votersSlice := make([]Voter, 0)
 
        if err = getVotersForProxyStmt.Select(&votersSlice, proxy.Id, decision.Id); err != nil {
-               logger.Println("Error getting voters for proxy:", err)
+               logger.Errorf("Error getting voters for proxy failed: %s", err)
                return
        }
        voters = &votersSlice
index aa8c7a8..5061a2a 100644 (file)
@@ -34,14 +34,14 @@ type NotificationMail interface {
 var NotifyMailChannel = make(chan NotificationMail, 1)
 
 func MailNotifier(quitMailNotifier chan int) {
-       logger.Println("Launched mail notifier")
+       logger.Infof("Launched mail notifier")
        for {
                select {
                case notification := <-NotifyMailChannel:
                        content := notification.GetNotificationContent()
                        mailText, err := buildMail(content.template, content.data)
                        if err != nil {
-                               logger.Println("ERROR building mail:", err)
+                               logger.Errorf("building mail failed: %s", err)
                                continue
                        }
 
@@ -58,10 +58,10 @@ func MailNotifier(quitMailNotifier chan int) {
 
                        d := gomail.NewDialer(config.MailServer.Host, config.MailServer.Port, "", "")
                        if err := d.DialAndSend(m); err != nil {
-                               logger.Println("ERROR sending mail:", err)
+                               logger.Errorf("sending mail failed: %s", err)
                        }
                case <-quitMailNotifier:
-                       fmt.Println("Ending mail notifier")
+                       logger.Infof("Ending mail notifier")
                        return
                }
        }