Start using l4g, and fix a buggy log message

src/github.com/otoolep/rqlite/command/write_command.go

@@ -3,6 +3,8 @@ package command
 import (
 	"github.com/otoolep/raft"
 	"github.com/otoolep/rqlite/db"
+
+	log "code.google.com/p/log4go"
 )
 
 // This command encapsulates a sqlite statement.
@@ -24,6 +26,7 @@ func (c *WriteCommand) CommandName() string {
 
 // Executes an sqlite statement.
 func (c *WriteCommand) Apply(server raft.Server) (interface{}, error) {
+	log.Debug("Applying WriteCommand: '%s'", c.Stmt)
 	db := server.Context().(*db.DB)
 	return nil, db.Execute(c.Stmt)
 }
@@ -49,24 +52,28 @@ func (c *TransactionWriteCommandSet) CommandName() string {
 // Executes a set of sqlite statements, within a transaction. All statements
 // will take effect, or none.
 func (c *TransactionWriteCommandSet) Apply(server raft.Server) (interface{}, error) {
+	log.Debug("Applying TransactionWriteCommandSet: %v", c.Stmts)
 	db := server.Context().(*db.DB)
 
 	err := db.StartTransaction()
 	if err != nil {
+		log.Error("Failed to start transaction:", err.Error())
 		return nil, err
 	}
 	for i := range c.Stmts {
 		err = db.Execute(c.Stmts[i])
 		if err != nil {
+			log.Error("Failed to execute statement within transaction", err.Error())
 			err2 := db.RollbackTransaction()
 			if err2 != nil {
-				// Log err2!
+				log.Error("Failed to rollback transaction:", err2.Error())
 			}
 			return nil, err
 		}
 	}
 	err = db.CommitTransaction()
 	if err != nil {
+		log.Error("Failed to commit transaction:", err.Error())
 		return nil, err
 	}
 	return nil, nil

src/github.com/otoolep/rqlite/db/db.go

@@ -3,10 +3,11 @@ package db
 import (
 	"database/sql"
 	"errors"
-	"log"
 	"os"
 
 	_ "github.com/mattn/go-sqlite3"
+
+	log "code.google.com/p/log4go"
 )
 
 const (
@@ -30,10 +31,11 @@ type RowResults []map[string]string
 func New(dbPath string) *DB {
 	os.Remove(dbPath)
 
-	log.Printf("database path is %s", dbPath)
+	log.Debug("SQLite database path is %s", dbPath)
 	dbc, err := sql.Open("sqlite3", dbPath)
 	if err != nil {
-		log.Fatal(err)
+		log.Error(err)
+		return nil
 	}
 	return &DB{
 		dbConn: dbc,
@@ -45,7 +47,7 @@ func New(dbPath string) *DB {
 func (db *DB) Query(query string) (RowResults, error) {
 	rows, err := db.dbConn.Query(query)
 	if err != nil {
-		log.Fatal("failed to execute query", err.Error())
+		log.Error("failed to execute SQLite query", err.Error())
 		return nil, QueryExecuteError
 	}
 	defer rows.Close()
@@ -62,7 +64,7 @@ func (db *DB) Query(query string) (RowResults, error) {
 	for rows.Next() {
 		err = rows.Scan(dest...)
 		if err != nil {
-			log.Fatal("failed to scan row", err)
+			log.Error("failed to scan SQLite row", err.Error())
 			return nil, RowScanError
 		}
 

src/github.com/otoolep/rqlite/main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"flag"
 	"fmt"
-	"log"
 	"math/rand"
 	"os"
 	"os/signal"
@@ -13,6 +12,8 @@ import (
 	"github.com/otoolep/raft"
 	"github.com/otoolep/rqlite/command"
 	"github.com/otoolep/rqlite/server"
+
+	log "code.google.com/p/log4go"
 )
 
 var host string
@@ -38,10 +39,10 @@ func main() {
 
 	// Set up profiling, if requested.
 	if cpuprofile != "" {
-		log.Printf("Profiling enabled")
+		log.Info("Profiling enabled")
 		f, err := os.Create(cpuprofile)
 		if err != nil {
-			log.Fatal("Unable to create path: %w", err)
+			log.Error("Unable to create path: %w", err)
 		}
 		defer f.Close()
 
@@ -54,24 +55,25 @@ func main() {
 
 	// Setup commands.
 	raft.RegisterCommand(&command.WriteCommand{})
+	raft.RegisterCommand(&command.TransactionWriteCommandSet{})
 
 	// Set the data directory.
 	if flag.NArg() == 0 {
 		flag.Usage()
-		log.Fatal("Data path argument required")
+		log.Error("Data path argument required")
 	}
 	path := flag.Arg(0)
 	if err := os.MkdirAll(path, 0744); err != nil {
-		log.Fatalf("Unable to create path: %v", err)
+		log.Error("Unable to create path: %v", err)
 	}
 
 	s := server.New(path, dbfile, host, port)
 	go func() {
-		log.Fatal(s.ListenAndServe(join))
+		log.Error(s.ListenAndServe(join))
 	}()
 
 	terminate := make(chan os.Signal, 1)
 	signal.Notify(terminate, os.Interrupt)
 	<-terminate
-	log.Printf("rqlite server stopped")
+	log.Info("rqlite server stopped")
 }

src/github.com/otoolep/rqlite/server/server.go

@@ -3,9 +3,9 @@ package server
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io/ioutil"
-	"log"
 	"math/rand"
 	"net/http"
 	"path"
@@ -18,6 +18,8 @@ import (
 	"github.com/otoolep/raft"
 	"github.com/otoolep/rqlite/command"
 	"github.com/otoolep/rqlite/db"
+
+	log "code.google.com/p/log4go"
 )
 
 // queryParam returns whether the given query param is set to true.
@@ -89,13 +91,14 @@ func (s *Server) connectionString() string {
 func (s *Server) ListenAndServe(leader string) error {
 	var err error
 
-	log.Printf("Initializing Raft Server: %s", s.path)
+	log.Info("Initializing Raft Server: %s", s.path)
 
 	// Initialize and start Raft server.
 	transporter := raft.NewHTTPTransporter("/raft", 200*time.Millisecond)
 	s.raftServer, err = raft.NewServer(s.name, s.path, transporter, nil, s.db, "")
 	if err != nil {
-		log.Fatal(err)
+		log.Error("Failed to create new Raft server", err.Error())
+		return err
 	}
 	transporter.Install(s.raftServer, s)
 	s.raftServer.Start()
@@ -103,33 +106,35 @@ func (s *Server) ListenAndServe(leader string) error {
 	if leader != "" {
 		// Join to leader if specified.
 
-		log.Println("Attempting to join leader:", leader)
+		log.Info("Attempting to join leader:", leader)
 
 		if !s.raftServer.IsLogEmpty() {
-			log.Fatal("Cannot join with an existing log")
+			log.Error("Cannot join with an existing log")
+			return errors.New("Cannot join with an existing log")
 		}
 		if err := s.Join(leader); err != nil {
-			log.Fatal(err)
+			log.Error("Failed to join leader", err.Error())
+			return err
 		}
 
 	} else if s.raftServer.IsLogEmpty() {
 		// Initialize the server by joining itself.
 
-		log.Println("Initializing new cluster")
+		log.Info("Initializing new cluster")
 
 		_, err := s.raftServer.Do(&raft.DefaultJoinCommand{
 			Name:             s.raftServer.Name(),
 			ConnectionString: s.connectionString(),
 		})
 		if err != nil {
-			log.Fatal(err)
+			log.Error("Failed to join to self", err.Error())
 		}
 
 	} else {
-		log.Println("Recovered from log")
+		log.Info("Recovered from log")
 	}
 
-	log.Println("Initializing HTTP server")
+	log.Info("Initializing HTTP server")
 
 	// Initialize and start HTTP server.
 	s.httpServer = &http.Server{
@@ -141,7 +146,7 @@ func (s *Server) ListenAndServe(leader string) error {
 	s.router.HandleFunc("/db", s.writeHandler).Methods("POST")
 	s.router.HandleFunc("/join", s.joinHandler).Methods("POST")
 
-	log.Println("Listening at:", s.connectionString())
+	log.Info("Listening at %s", s.connectionString())
 
 	return s.httpServer.ListenAndServe()
 }
@@ -184,14 +189,17 @@ func (s *Server) joinHandler(w http.ResponseWriter, req *http.Request) {
 }
 
 func (s *Server) readHandler(w http.ResponseWriter, req *http.Request) {
+	log.Debug("readHandler for URL: %s", req.URL)
 	b, err := ioutil.ReadAll(req.Body)
 	if err != nil {
+		log.Debug("Bad HTTP request", err.Error())
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
 
 	r, err := s.db.Query(string(b))
 	if err != nil {
+		log.Debug("Bad HTTP request", err.Error())
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 	}
 
@@ -202,6 +210,7 @@ func (s *Server) readHandler(w http.ResponseWriter, req *http.Request) {
 		b, err = json.Marshal(r)
 	}
 	if err != nil {
+		log.Debug("Failed to marshal JSON data", err.Error())
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -209,9 +218,11 @@ func (s *Server) readHandler(w http.ResponseWriter, req *http.Request) {
 }
 
 func (s *Server) writeHandler(w http.ResponseWriter, req *http.Request) {
+	log.Debug("writeHandler for URL: %s", req.URL)
 	// Read the value from the POST body.
 	b, err := ioutil.ReadAll(req.Body)
 	if err != nil {
+		log.Debug("Bad HTTP request", err.Error())
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -220,6 +231,7 @@ func (s *Server) writeHandler(w http.ResponseWriter, req *http.Request) {
 	// Execute the command against the Raft server.
 	switch {
 	case len(stmts) == 0:
+		log.Debug("No database execute commands supplied")
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	case len(stmts) == 1:
@@ -227,8 +239,10 @@ func (s *Server) writeHandler(w http.ResponseWriter, req *http.Request) {
 	case len(stmts) > 1:
 		transaction, _ := isTransaction(req)
 		if transaction {
+			log.Debug("Transaction requested")
 			_, err = s.raftServer.Do(command.NewTransactionWriteCommandSet(stmts))
 		} else {
+			log.Debug("No transaction requested")
 			// Do each individually, returning JSON respoonse
 		}
 	}