Moved chapter 3. Added 4 and 5.

Author: technosophos

chapter3_original_depenency_management/README.md

@@ -0,0 +1,4 @@
+In the original version of Go In Practice, we wrote an entire chapter on
+dependency management. But during the course of writing the book, Go 1.5
+was released, which (in our opinion) solves most of the problems we were
+dealing with when we first wrote the book.

chapter3/mygodep/main.go renamed to chapter3_original_depenency_management/mygodep/main.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	var msg string
+	defer func() {
+		fmt.Println(msg)
+	}()
+	msg = "Hello world"
+}

chapter3/myproject/glide.yaml renamed to chapter3_original_depenency_management/myproject/glide.yaml

@@ -0,0 +1,3 @@
+one,two
+hello,world
+goodbye,world

chapter3/myproject/history.txt renamed to chapter3_original_depenency_management/myproject/history.txt

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+)
+
+// Concat concatenates a bunch of strings.
+// Strings are separated by spaces.
+// It returns an empty string and an error if no strings were passed in.
+func Concat(parts ...string) (string, error) {
+	if len(parts) == 0 {
+		return "", errors.New("No strings supplied")
+	}
+
+	return strings.Join(parts, " "), nil
+}
+
+func main() {
+
+	args := os.Args[1:]
+
+	/*
+		if result, err := Concat(args...); err != nil {
+			fmt.Printf("Error: %s\n", err)
+		} else {
+			fmt.Printf("Concatenated string: '%s'\n", result)
+		}
+	*/
+	result, _ := Concat(args...)
+	fmt.Printf("Concatenated string: '%s'\n", result)
+
+}
+
+func assumeGoodDesign() {
+	// Streamlined error handling
+	batch := []string{}
+	result, _ := Concat(batch...)
+	fmt.Printf("Concatenated string: '%s'\n", result)
+
+}

chapter4/closure_scope.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"errors"
+	"net/http"
+)
+
+func main() {
+	http.HandleFunc("/", handler)
+	http.ListenAndServe(":8080", nil)
+}
+func handler(res http.ResponseWriter, req *http.Request) {
+	panic(errors.New("Fake panic!"))
+}

chapter4/data.csv

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	err := &ParseError{
+		Message: "Unexpected char ';'",
+		Line:    5,
+		Char:    38,
+	}
+
+	fmt.Println(err.Error())
+}
+
+type ParseError struct {
+	Message    string
+	Line, Char int
+}
+
+func (p *ParseError) Error() string {
+	format := "%s on Line %d, Char %d"
+	return fmt.Sprintf(format, p.Message, p.Line, p.Char)
+}

chapter4/error_example.go

@@ -0,0 +1,7 @@
+package main
+
+import "errors"
+
+func main() {
+	panic(errors.New("Something bad happened."))
+}

chapter4/http_server.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+func main() {
+	msg := "Everything's fine"
+	defer func() {
+		if err := recover(); err != nil {
+			fmt.Printf("Trapped panic: %s (%T)\n", err, err)
+		}
+		fmt.Println(msg)
+	}()
+
+	yikes()
+}
+
+func yikes() {
+	panic(errors.New("Something bad happened."))
+}

chapter4/parser_error.go

@@ -0,0 +1,18 @@
+package safely
+
+import (
+	"log"
+)
+
+type GoDoer func()
+
+func Go(todo GoDoer) {
+	go func() {
+		defer func() {
+			if err := recover(); err != nil {
+				log.Printf("Panic in safely.Go: %s", err)
+			}
+		}()
+		todo()
+	}()
+}

chapter4/proper_panic.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"./safely"
+	"errors"
+	"time"
+)
+
+func message() {
+	println("Inside goroutine")
+	panic(errors.New("Oops!"))
+}
+
+func main() {
+	safely.Go(message)
+	println("Outside goroutine")
+	time.Sleep(200)
+}

chapter4/recover_panic.go

@@ -0,0 +1,13 @@
+package main
+
+import "errors"
+
+func main() {
+	errA := errors.New("Error")
+	//errB := errors.New("Error")
+
+	if errA != errA {
+		panic("Expected same!")
+	}
+	println("Done")
+}

chapter4/safely/safely.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	defer goodbye()
+
+	fmt.Println("Hello world.")
+}
+
+func goodbye() {
+	fmt.Println("Goodbye")
+}

chapter4/safely_example.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"net"
+)
+
+func main() {
+	listen()
+}
+
+func listen() {
+	listener, err := net.Listen("tcp", ":1026")
+	if err != nil {
+		fmt.Println("Failed to open port on 1026")
+		return
+	}
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			fmt.Println("Error accepting connection")
+			continue
+		}
+
+		go handle(conn)
+	}
+}
+
+func handle(conn net.Conn) {
+	defer func() {
+		if err := recover(); err != nil {
+			fmt.Printf("Fatal error: %s", err)
+		}
+		conn.Close()
+	}()
+	reader := bufio.NewReader(conn)
+
+	data, err := reader.ReadBytes('\n')
+	if err != nil {
+		fmt.Println("Failed to read from socket.")
+	}
+
+	response(data, conn)
+}
+
+func response(data []byte, conn net.Conn) {
+	conn.Write(data)
+	panic(errors.New("Pretend I'm a real error"))
+}

chapter4/same_error.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"net"
+)
+
+func main() {
+	listen()
+}
+
+func listen() {
+	defer func() {
+		if err := recover(); err != nil {
+			fmt.Printf("Caught a panic and recovered")
+		}
+	}()
+	listener, err := net.Listen("tcp", ":1026")
+	if err != nil {
+		fmt.Println("Failed to open port on 1026")
+		return
+	}
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			fmt.Println("Error accepting connection")
+			continue
+		}
+
+		go handle(conn)
+	}
+}
+
+func handle(conn net.Conn) {
+	reader := bufio.NewReader(conn)
+
+	data, err := reader.ReadBytes('\n')
+	if err != nil {
+		fmt.Println("Failed to read from socket.")
+		conn.Close()
+	}
+
+	response(data, conn)
+}
+
+func response(data []byte, conn net.Conn) {
+	defer func() {
+		conn.Close()
+	}()
+	conn.Write(data)
+	panic(errors.New("Failure in response!"))
+}

chapter4/simple_defer.go

@@ -0,0 +1,6 @@
+package main
+
+func main() {
+	defer func() { println("a") }()
+	defer func() { println("b") }()
+}

chapter4/simple_server.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+)
+
+var ErrTimeout = errors.New("The request timed out")
+var ErrRejected = errors.New("The request was rejected")
+
+var random = rand.New(rand.NewSource(35))
+
+//var random = rand.New(rand.NewSource(78))
+
+func main() {
+	response, err := SendRequest("Hello")
+	for err == ErrTimeout {
+		fmt.Println("Timeout. Retrying.")
+		response, err = SendRequest("Hello")
+	}
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Println(response)
+	}
+}
+
+func SendRequest(req string) (string, error) {
+
+	switch random.Int() % 3 {
+	case 0:
+		return "Success", nil
+	case 1:
+		return "", ErrRejected
+	default:
+		return "", ErrTimeout
+	}
+}