Use log instead of fmt for logging

Also fix up a few errors to lower case

cmd/rove-accountant/internal/accounts.go

@@ -42,7 +42,7 @@ func (a *Accountant) RegisterAccount(name string) (acc Account, err error) {
 	// Verify this acount isn't already registered
 	for _, a := range a.Accounts {
 		if a.Name == acc.Name {
-			return Account{}, fmt.Errorf("Account name already registered")
+			return Account{}, fmt.Errorf("account name already registered")
 		}
 	}
 

cmd/rove-accountant/main.go

@@ -31,15 +31,15 @@ func (a *accountantServer) Register(ctx context.Context, in *accounts.RegisterIn
 	defer a.sync.Unlock()
 
 	// Try and register the account itself
-	fmt.Printf("Registering account: %s\n", in.Name)
+	log.Printf("Registering account: %s\n", in.Name)
 	if _, err := a.accountant.RegisterAccount(in.Name); err != nil {
-		fmt.Printf("Error: %s\n", err)
+		log.Printf("Error: %s\n", err)
 		return &accounts.RegisterResponse{Success: false, Error: fmt.Sprintf("error registering account: %s", err)}, nil
 	}
 
 	// Save out the accounts
 	if err := persistence.Save("accounts", a.accountant); err != nil {
-		fmt.Printf("Error: %s\n", err)
+		log.Printf("Error: %s\n", err)
 		return &accounts.RegisterResponse{Success: false, Error: fmt.Sprintf("failed to save accounts: %s", err)}, nil
 	}
 
@@ -52,10 +52,10 @@ func (a *accountantServer) AssignValue(_ context.Context, in *accounts.DataKeyVa
 	defer a.sync.RUnlock()
 
 	// Try and assign the data
-	fmt.Printf("Assigning value for account %s: %s->%s\n", in.Account, in.Key, in.Value)
+	log.Printf("Assigning value for account %s: %s->%s\n", in.Account, in.Key, in.Value)
 	err := a.accountant.AssignData(in.Account, in.Key, in.Value)
 	if err != nil {
-		fmt.Printf("Error: %s\n", err)
+		log.Printf("Error: %s\n", err)
 		return &accounts.Response{Success: false, Error: err.Error()}, nil
 	}
 
@@ -69,10 +69,10 @@ func (a *accountantServer) GetValue(_ context.Context, in *accounts.DataKey) (*a
 	defer a.sync.RUnlock()
 
 	// Try and fetch the rover
-	fmt.Printf("Getting value for account %s: %s\n", in.Account, in.Key)
+	log.Printf("Getting value for account %s: %s\n", in.Account, in.Key)
 	data, err := a.accountant.GetValue(in.Account, in.Key)
 	if err != nil {
-		fmt.Printf("Error: %s\n", err)
+		log.Printf("Error: %s\n", err)
 		return &accounts.DataResponse{Success: false, Error: err.Error()}, nil
 	}
 
@@ -110,12 +110,12 @@ func main() {
 	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
 	go func() {
 		<-c
-		fmt.Println("Quit requested, exiting...")
+		log.Println("Quit requested, exiting...")
 		grpcServer.Stop()
 	}()
 
 	// Serve the RPC server
-	fmt.Printf("Serving accountant on %s\n", address)
+	log.Printf("Serving accountant on %s\n", address)
 	if err := grpcServer.Serve(lis); err != nil {
 		log.Fatalf("failed to server gRPC: %s", err)
 	}

cmd/rove-server/internal/routes.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"time"
 
@@ -82,7 +83,7 @@ func HandleRegister(s *Server, vars map[string]string, b io.ReadCloser, w io.Wri
 	var data rove.RegisterData
 	err := json.NewDecoder(b).Decode(&data)
 	if err != nil {
-		fmt.Printf("Failed to decode json: %s\n", err)
+		log.Printf("Failed to decode json: %s\n", err)
 		response.Error = err.Error()
 
 	} else if len(data.Name) == 0 {
@@ -109,7 +110,7 @@ func HandleRegister(s *Server, vars map[string]string, b io.ReadCloser, w io.Wri
 		response.Success = true
 	}
 
-	fmt.Printf("register response:%+v\n", response)
+	log.Printf("register response:%+v\n", response)
 	return response, nil
 }
 
@@ -124,7 +125,7 @@ func HandleCommand(s *Server, vars map[string]string, b io.ReadCloser, w io.Writ
 	// Decode the commands, verify them and the account, and execute the commands
 	var data rove.CommandData
 	if err := json.NewDecoder(b).Decode(&data); err != nil {
-		fmt.Printf("Failed to decode json: %s\n", err)
+		log.Printf("Failed to decode json: %s\n", err)
 		response.Error = err.Error()
 
 	}
@@ -151,7 +152,7 @@ func HandleCommand(s *Server, vars map[string]string, b io.ReadCloser, w io.Writ
 		response.Success = true
 	}
 
-	fmt.Printf("command response \taccount:%s\tresponse:%+v\n", id, response)
+	log.Printf("command response \taccount:%s\tresponse:%+v\n", id, response)
 	return response, nil
 }
 
@@ -189,7 +190,7 @@ func HandleRadar(s *Server, vars map[string]string, b io.ReadCloser, w io.Writer
 		response.Success = true
 	}
 
-	fmt.Printf("radar response \taccount:%s\tresponse:%+v\n", id, response)
+	log.Printf("radar response \taccount:%s\tresponse:%+v\n", id, response)
 	return response, nil
 }
 
@@ -223,6 +224,6 @@ func HandleRover(s *Server, vars map[string]string, b io.ReadCloser, w io.Writer
 		response.Success = true
 	}
 
-	fmt.Printf("rover response \taccount:%s\tresponse:%+v\n", id, response)
+	log.Printf("rover response \taccount:%s\tresponse:%+v\n", id, response)
 	return response, nil
 }

cmd/rove-server/internal/server.go

@@ -116,7 +116,7 @@ func (s *Server) Initialise(fillWorld bool) (err error) {
 	s.sync.Add(1)
 
 	// Connect to the accountant
-	fmt.Printf("Dialing accountant on %s\n", accountantAddress)
+	log.Printf("Dialing accountant on %s\n", accountantAddress)
 	s.clientConn, err = grpc.Dial(accountantAddress, grpc.WithInsecure())
 	if err != nil {
 		return err
@@ -139,7 +139,7 @@ func (s *Server) Initialise(fillWorld bool) (err error) {
 	}
 
 	// Start the listen
-	fmt.Printf("Listening on %s\n", s.server.Addr)
+	log.Printf("Listening on %s\n", s.server.Addr)
 	if s.listener, err = net.Listen("tcp", s.server.Addr); err != nil {
 		return err
 	}
@@ -164,7 +164,7 @@ func (s *Server) Run() {
 			s.sync.Add(1)
 			defer s.sync.Done()
 
-			fmt.Println("Executing server tick")
+			log.Println("Executing server tick")
 
 			// Run the command queues
 			s.world.ExecuteCommandQueues()
@@ -175,7 +175,7 @@ func (s *Server) Run() {
 			log.Fatal(err)
 		}
 		s.schedule.Start()
-		fmt.Printf("First server tick scheduled for %s\n", s.schedule.Entries()[0].Next.Format("15:04:05"))
+		log.Printf("First server tick scheduled for %s\n", s.schedule.Entries()[0].Next.Format("15:04:05"))
 	}
 
 	// Serve the http requests
@@ -252,7 +252,7 @@ func (s *Server) LoadWorld() error {
 func (s *Server) wrapHandler(method string, handler Handler) func(w http.ResponseWriter, r *http.Request) {
 	return func(w http.ResponseWriter, r *http.Request) {
 		// Log the request
-		fmt.Printf("%s\t%s\n", r.Method, r.RequestURI)
+		log.Printf("%s\t%s\n", r.Method, r.RequestURI)
 
 		vars := mux.Vars(r)
 
@@ -261,11 +261,11 @@ func (s *Server) wrapHandler(method string, handler Handler) func(w http.Respons
 			w.WriteHeader(http.StatusMethodNotAllowed)
 
 		} else if val, err := handler(s, vars, r.Body, w); err != nil {
-			fmt.Printf("Failed to handle http request: %s", err)
+			log.Printf("Failed to handle http request: %s", err)
 			w.WriteHeader(http.StatusInternalServerError)
 
 		} else if err := json.NewEncoder(w).Encode(val); err != nil {
-			fmt.Printf("Failed to encode reply to json: %s", err)
+			log.Printf("Failed to encode reply to json: %s", err)
 			w.WriteHeader(http.StatusInternalServerError)
 
 		} else {
@@ -280,17 +280,17 @@ func (s *Server) SpawnRoverForAccount(account string) (game.RoverAttributes, uui
 		return game.RoverAttributes{}, uuid.UUID{}, err
 
 	} else if attribs, err := s.world.RoverAttributes(inst); err != nil {
-		return game.RoverAttributes{}, uuid.UUID{}, fmt.Errorf("No attributes found for created rover: %s", err)
+		return game.RoverAttributes{}, uuid.UUID{}, fmt.Errorf("no attributes found for created rover: %s", err)
 
 	} else {
 		keyval := accounts.DataKeyValue{Account: account, Key: "rover", Value: inst.String()}
 		resp, err := s.accountant.AssignValue(context.Background(), &keyval)
 		if err != nil || !resp.Success {
-			fmt.Printf("Failed to assign rover to account, %s, %s", err, resp.Error)
+			log.Printf("Failed to assign rover to account, %s, %s", err, resp.Error)
 
 			// Try and clear up the rover
 			if err := s.world.DestroyRover(inst); err != nil {
-				fmt.Printf("Failed to destroy rover after failed rover assign: %s", err)
+				log.Printf("Failed to destroy rover after failed rover assign: %s", err)
 			}
 
 			return game.RoverAttributes{}, uuid.UUID{}, err

cmd/rove-server/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"flag"
-	"fmt"
 	"log"
 	"os"
 	"os/signal"
@@ -32,11 +31,11 @@ func InnerMain() {
 
 	// Print the version if requested
 	if *ver {
-		fmt.Println(version.Version)
+		log.Println(version.Version)
 		return
 	}
 
-	fmt.Printf("Initialising version %s...\n", version.Version)
+	log.Printf("Initialising version %s...\n", version.Version)
 
 	// Set the persistence path
 	persistence.SetPath(data)
@@ -67,7 +66,7 @@ func InnerMain() {
 	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
 	go func() {
 		<-c
-		fmt.Println("Quit requested, exiting...")
+		log.Println("Quit requested, exiting...")
 		if err := s.Stop(); err != nil {
 			panic(err)
 		}
@@ -82,7 +81,7 @@ func InnerMain() {
 	}
 
 	// Run the server
-	fmt.Printf("Serving HTTP on %s\n", s.Addr())
+	log.Printf("Serving HTTP on %s\n", s.Addr())
 	s.Run()
 
 	// Close the server

cmd/rove/main.go

@@ -125,7 +125,7 @@ func InnerMain(command string) error {
 			return err
 
 		case !response.Success:
-			return fmt.Errorf("Server returned failure: %s", response.Error)
+			return fmt.Errorf("server returned failure: %s", response.Error)
 
 		default:
 			fmt.Printf("Registered account with id: %s\n", *name)
@@ -153,7 +153,7 @@ func InnerMain(command string) error {
 			return err
 
 		case !response.Success:
-			return fmt.Errorf("Server returned failure: %s", response.Error)
+			return fmt.Errorf("server returned failure: %s", response.Error)
 
 		default:
 			fmt.Printf("Request succeeded\n")
@@ -170,7 +170,7 @@ func InnerMain(command string) error {
 			return err
 
 		case !response.Success:
-			return fmt.Errorf("Server returned failure: %s", response.Error)
+			return fmt.Errorf("server returned failure: %s", response.Error)
 
 		default:
 			// Print out the radar
@@ -188,7 +188,7 @@ func InnerMain(command string) error {
 			return err
 
 		case !response.Success:
-			return fmt.Errorf("Server returned failure: %s", response.Error)
+			return fmt.Errorf("server returned failure: %s", response.Error)
 
 		default:
 			fmt.Printf("attributes: %+v\n", response.Attributes)

pkg/bearing/bearing.go

@@ -56,7 +56,7 @@ func FromString(s string) (Bearing, error) {
 			return Bearing(i), nil
 		}
 	}
-	return -1, fmt.Errorf("Unknown bearing: %s", s)
+	return -1, fmt.Errorf("unknown bearing: %s", s)
 }
 
 var bearingVectors = []vector.Vector{

pkg/game/atlas.go

@@ -174,7 +174,7 @@ func (a *Atlas) Grow(size int) error {
 	}
 	delta := size - a.Size
 	if delta < 0 {
-		return fmt.Errorf("Cannot shrink an atlas")
+		return fmt.Errorf("cannot shrink an atlas")
 	} else if delta == 0 {
 		return nil
 	}

pkg/game/world.go

@@ -2,6 +2,7 @@ package game
 
 import (
 	"fmt"
+	"log"
 	"math"
 	"math/rand"
 	"strings"
@@ -101,7 +102,7 @@ func (w *World) SpawnRover() (uuid.UUID, error) {
 		return uuid.Nil, err
 	}
 
-	fmt.Printf("Spawned rover at %+v\n", rover.Attributes.Pos)
+	log.Printf("Spawned rover at %+v\n", rover.Attributes.Pos)
 
 	// Append the rover to the list
 	w.Rovers[rover.Id] = rover
@@ -167,7 +168,7 @@ func (w *World) WarpRover(id uuid.UUID, pos vector.Vector) error {
 		if tile, err := w.Atlas.GetTile(pos); err != nil {
 			return fmt.Errorf("coudln't get state of destination rover tile: %s", err)
 		} else if tile == TileRover {
-			return fmt.Errorf("Can't warp rover to occupied tile, check before warping")
+			return fmt.Errorf("can't warp rover to occupied tile, check before warping")
 		} else if err := w.Atlas.SetTile(pos, TileRover); err != nil {
 			return fmt.Errorf("coudln't set rover tile: %s", err)
 		} else if err := w.Atlas.SetTile(i.Attributes.Pos, TileEmpty); err != nil {
@@ -328,7 +329,7 @@ func (w *World) ExecuteCommandQueues() {
 			// Execute the command and clear up if requested
 			if done, err := w.ExecuteCommand(&c, rover); err != nil {
 				w.CommandQueue[rover] = cmds[1:]
-				fmt.Println(err)
+				log.Println(err)
 			} else if done {
 				w.CommandQueue[rover] = cmds[1:]
 			} else {
@@ -349,7 +350,7 @@ func (w *World) ExecuteCommandQueues() {
 
 // ExecuteCommand will execute a single command
 func (w *World) ExecuteCommand(c *Command, rover uuid.UUID) (finished bool, err error) {
-	fmt.Printf("Executing command: %+v\n", *c)
+	log.Printf("Executing command: %+v\n", *c)
 
 	switch c.Command {
 	case "move":
@@ -380,7 +381,7 @@ func PrintTiles(tiles []Tile) {
 	num := int(math.Sqrt(float64(len(tiles))))
 	for j := num - 1; j >= 0; j-- {
 		for i := 0; i < num; i++ {
-			fmt.Printf("%d", tiles[i+num*j])
+			log.Printf("%d", tiles[i+num*j])
 		}
 		fmt.Print("\n")
 	}

pkg/persistence/persistence.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"log"
 	"os"
 	"path"
 )
@@ -38,7 +39,7 @@ func Save(name string, data interface{}) error {
 		}
 	}
 
-	fmt.Printf("Saved %s\n", p)
+	log.Printf("Saved %s\n", p)
 	return nil
 }
 
@@ -48,7 +49,7 @@ func Load(name string, data interface{}) error {
 	// Don't load anything if the file doesn't exist
 	_, err := os.Stat(p)
 	if os.IsNotExist(err) {
-		fmt.Printf("File %s didn't exist, loading with fresh data\n", p)
+		log.Printf("File %s didn't exist, loading with fresh data\n", p)
 		return nil
 	}
 
@@ -56,13 +57,13 @@ func Load(name string, data interface{}) error {
 	if b, err := ioutil.ReadFile(p); err != nil {
 		return err
 	} else if len(b) == 0 {
-		fmt.Printf("File %s was empty, loading with fresh data\n", p)
+		log.Printf("File %s was empty, loading with fresh data\n", p)
 		return nil
 	} else if err := json.Unmarshal(b, data); err != nil {
 		return fmt.Errorf("failed to load file %s error: %s", p, err)
 	}
 
-	fmt.Printf("Loaded %s\n", p)
+	log.Printf("Loaded %s\n", p)
 	return nil
 }
 
@@ -76,7 +77,7 @@ func doAll(f saveLoadFunc, args ...interface{}) error {
 			var ok bool
 			name, ok = a.(string)
 			if !ok {
-				return fmt.Errorf("Incorrect args")
+				return fmt.Errorf("incorrect args")
 			}
 		} else {
 			if err := f(name, a); err != nil {