Some Update

Author: tmpbook

ch01 入门/11-server1/main.go

@@ -8,7 +8,7 @@ import (
 
 func main() {
 	http.HandleFunc("/", handler)
-	log.Fatal(http.ListenAndServe("localhost:8000", nil))
+	log.Fatal(http.ListenAndServe(":8000", nil))
 }
 
 func handler(w http.ResponseWriter, r *http.Request) {

channels/worker.go

@@ -0,0 +1,47 @@
+package workers
+
+type WG struct {
+	max     int
+	allDone chan bool
+	main    chan func()
+}
+
+func New(n int) WG {
+
+	procDone := make(chan bool)
+	res := WG{
+		allDone: make(chan bool),
+		main:    make(chan func()),
+	}
+
+	for i := 0; i < n; i++ {
+		go func() {
+			for f := range res.main {
+				f()
+			}
+			procDone <- true
+		}()
+	}
+
+	go func() {
+		for i := 0; i < n; i++ {
+			_ = <-procDone
+		}
+		res.allDone <- true
+
+	}()
+	return res
+
+}
+
+func (wg WG) Add(f func()) {
+	wg.main <- f
+}
+
+//Wait, Call Once when all funcs have been added to wait for completion.
+//If you don't care to wait, 'go Wait' lol
+func (wg WG) Wait() {
+	close(wg.main)
+	_ = <-wg.allDone
+
+}

channels/worker_test.go

@@ -0,0 +1,30 @@
+package workers
+
+import (
+	"sync"
+	"testing"
+	"time"
+)
+
+func Test_Workers(t *testing.T) {
+	wg := New(50)
+	var l sync.Mutex
+	p := 0
+
+	for i := 0; i < 1000; i++ {
+		//	fmt.Println("Adding :", i)
+		wg.Add(func() {
+			time.Sleep(time.Second / 10)
+			l.Lock()
+			p++
+			l.Unlock()
+
+		})
+	}
+	wg.Wait()
+	if p != 1000 {
+		t.Log("P not reached it's goal", p)
+		t.Fail()
+	}
+
+}

demo/decorator/compute_time.go

@@ -0,0 +1,43 @@
+package decorator
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"time"
+)
+
+type SumFunc func(int64, int64) int64
+
+func getFuncName(i interface{}) string {
+	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
+}
+
+func timedSumFunc(f SumFunc) SumFunc {
+	return func(start, end int64) int64 {
+		defer func(t time.Time) {
+			fmt.Printf("--- Time Elapsed (%s): %v ---\n",
+				getFuncName(f), time.Since(t))
+		}(time.Now())
+		return f(start, end)
+	}
+}
+
+func Sum1(start, end int64) int64 {
+	var sum int64
+	sum = 0
+	if start > end {
+		start, end = end, start
+	}
+	for i := start; i <= end; i++ {
+		sum++
+	}
+	return sum
+}
+
+func Sum2(start, end int64) int64 {
+	if start > end {
+		start, end = end, start
+	}
+	return (end - start + 1) * (end + start) / 2
+}

demo/decorator/decorator_test.go

@@ -0,0 +1,46 @@
+package decorator
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"testing"
+)
+
+func Hello(s string) {
+	fmt.Println(s)
+}
+func Test(t *testing.T) {
+
+	decorator(Hello)("Hello, World!")
+
+}
+
+func Test_compute(t *testing.T) {
+
+	sum1 := timedSumFunc(Sum1)
+	sum2 := timedSumFunc(Sum2)
+	fmt.Printf("%d, %d\n", sum1(-10000, 10000000), sum2(-10000, 10000000))
+}
+
+func hello(w http.ResponseWriter, r *http.Request) {
+	log.Printf("Recieved Request %s from %s\n", r.URL.Path, r.RemoteAddr)
+	fmt.Fprintf(w, "Hello, World! "+r.URL.Path)
+}
+
+func Test_http_server(t *testing.T) {
+	http.HandleFunc("/hello", WithServerHeader(hello))
+	err := http.ListenAndServe(":8080", nil)
+	if err != nil {
+		log.Fatal("ListenAndServe: ", err)
+	}
+}
+
+func Test_http_server_enhance(t *testing.T) {
+	http.HandleFunc("/v4/hello", Handler(hello,
+		WithAuthCookie, WithServerHeader, WithBasicAuth, WithDebugLog))
+	err := http.ListenAndServe(":8080", nil)
+	if err != nil {
+		log.Fatal("ListenAndServe: ", err)
+	}
+}

demo/decorator/hello_world.go

@@ -0,0 +1,12 @@
+package decorator
+
+import "fmt"
+
+func decorator(f func(s string)) func(s string) {
+
+	return func(s string) {
+		fmt.Println("Started")
+		f(s)
+		fmt.Println("Done")
+	}
+}

demo/decorator/http_server_enhance.go

@@ -0,0 +1,62 @@
+package decorator
+
+import (
+	"log"
+	"net/http"
+	"strings"
+)
+
+type HttpHandlerDecorator func(http.HandlerFunc) http.HandlerFunc
+
+func Handler(h http.HandlerFunc, decors ...HttpHandlerDecorator) http.HandlerFunc {
+	for i := range decors {
+		d := decors[len(decors)-1-i] // iterate in reverse
+		h = d(h)
+	}
+	return h
+}
+
+func WithServerHeader(h http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		log.Println("--->WithServerHeader()")
+		w.Header().Set("Server", "HelloServer v0.0.1")
+		h(w, r)
+	}
+}
+
+func WithAuthCookie(h http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		log.Println("--->WithAuthCookie()")
+		cookie := &http.Cookie{Name: "Auth", Value: "Pass", Path: "/"}
+		http.SetCookie(w, cookie)
+		h(w, r)
+	}
+}
+
+func WithBasicAuth(h http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		log.Println("--->WithBasicAuth()")
+		cookie, err := r.Cookie("Auth")
+		if err != nil || cookie.Value != "Pass" {
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+		h(w, r)
+	}
+}
+
+func WithDebugLog(h http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		log.Println("--->WithDebugLog")
+		r.ParseForm()
+		log.Println(r.Form)
+		log.Println("path", r.URL.Path)
+		log.Println("scheme", r.URL.Scheme)
+		log.Println(r.Form["url_long"])
+		for k, v := range r.Form {
+			log.Println("key:", k)
+			log.Println("val:", strings.Join(v, ""))
+		}
+		h(w, r)
+	}
+}

demo/sort/sort.go

@@ -0,0 +1,45 @@
+package sort
+
+import (
+	"sort"
+)
+
+// A couple of type definitions to make the units clear.
+type earthMass float64
+type au float64
+
+// A Planet defines the properties of a solar system object.
+type Planet struct {
+	name     string
+	mass     earthMass
+	distance au
+}
+
+// By is the type of a "less" function that defines the ordering of its Planet arguments.
+type By func(p1, p2 *Planet) bool
+
+// Sort is a method on the function type, By, that sorts the argument slice according to the function.
+func (by By) Sort(planets []Planet) {
+	ps := &planetSorter{
+		planets: planets,
+		by:      by, // The Sort method's receiver is the function (closure) that defines the sort order.
+	}
+	sort.Sort(ps)
+}
+
+// planetSorter joins a By function and a slice of Planets to be sorted.
+type planetSorter struct {
+	planets []Planet
+	by      func(p1, p2 *Planet) bool // Closure used in the Less method.
+}
+
+func (s *planetSorter) Len() int           { return len(s.planets) }
+func (s *planetSorter) Swap(i, j int)      { s.planets[i], s.planets[j] = s.planets[j], s.planets[i] }
+func (s *planetSorter) Less(i, j int) bool { return s.by(&s.planets[i], &s.planets[j]) }
+
+var planets = []Planet{
+	{"Mercury", 0.055, 0.4},
+	{"Venus", 0.815, 0.7},
+	{"Earth", 1.0, 1.0},
+	{"Mars", 0.107, 1.5},
+}

demo/sort/sort_test.go

@@ -0,0 +1,35 @@
+package sort
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_sort(t *testing.T) {
+	// Closures that order the Planet structure.
+	name := func(p1, p2 *Planet) bool {
+		return p1.name < p2.name
+	}
+	mass := func(p1, p2 *Planet) bool {
+		return p1.mass < p2.mass
+	}
+	distance := func(p1, p2 *Planet) bool {
+		return p1.distance < p2.distance
+	}
+	decreasingDistance := func(p1, p2 *Planet) bool {
+		return !distance(p1, p2)
+	}
+
+	// Sort the planets by the various criteria.
+	By(name).Sort(planets)
+	fmt.Println("By name:", planets)
+
+	By(mass).Sort(planets)
+	fmt.Println("By mass:", planets)
+
+	By(distance).Sort(planets)
+	fmt.Println("By distance:", planets)
+
+	By(decreasingDistance).Sort(planets)
+	fmt.Println("By decreasing distance:", planets)
+}