Add context google demo

tmpbook · tmpbook · commit 94ac29bfddcf · 2018-01-04T20:51:34.000+08:00
diff --git a/context/easy_demo/main.go b/context/easy_demo/main.go
diff --git a/context/google_demo/google/google.go b/context/google_demo/google/google.go
@@ -0,0 +1,93 @@
+// Package google provides a function to do Google searches using the Google Web
+// Search API. See https://developers.google.com/web-search/docs/
+//
+// This package is an example to accompany https://blog.golang.org/context.
+// It is not intended for use by others.
+//
+// Google has since disabled its search API,
+// and so this package is no longer useful.
+package google
+
+import (
+	"context"
+	"encoding/json"
+	"learn-golang/context/google_demo/userip"
+	"net/http"
+)
+
+// Results is an ordered list of search results.
+type Results []Result
+
+// A Result contains the title and URL of a search result.
+type Result struct {
+	Title, URL string
+}
+
+// Search sends query to Google search and returns the results.
+func Search(ctx context.Context, query string) (Results, error) {
+	// Prepare the Google Search API request.
+	req, err := http.NewRequest("GET", "https://ajax.googleapis.com/ajax/services/search/web?v=1.0", nil)
+	if err != nil {
+		return nil, err
+	}
+	q := req.URL.Query()
+	q.Set("q", query)
+
+	// If ctx is carrying the user IP address, forward it to the server.
+	// Google APIs use the user IP to distinguish server-initiated requests
+	// from end-user requests.
+	if userIP, ok := userip.FromContext(ctx); ok {
+		q.Set("userip", userIP.String())
+	}
+	req.URL.RawQuery = q.Encode()
+
+	// Issue the HTTP request and handle the response. The httpDo function
+	// cancels the request if ctx.Done is closed.
+	var results Results
+	err = httpDo(ctx, req, func(resp *http.Response, err error) error {
+		if err != nil {
+			return err
+		}
+		defer resp.Body.Close()
+
+		// Parse the JSON search result.
+		// https://developers.google.com/web-search/docs/#fonje
+		var data struct {
+			ResponseData struct {
+				Results []struct {
+					TitleNoFormatting string
+					URL               string
+				}
+			}
+		}
+		if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+			return err
+		}
+		for _, res := range data.ResponseData.Results {
+			results = append(results, Result{Title: res.TitleNoFormatting, URL: res.URL})
+		}
+		return nil
+	})
+	// httpDo waits for the closure we provided to return, so it's safe to
+	// read results here.
+	return results, err
+}
+
+// httpDo issues the HTTP request and calls f with the response. If ctx.Done is
+// closed while the request or f is running, httpDo cancels the request, waits
+// for f to exit, and returns ctx.Err. Otherwise, httpDo returns f's error.
+func httpDo(ctx context.Context, req *http.Request, f func(*http.Response, error) error) error {
+	// Run the HTTP request in a goroutine and pass the response to f.
+	tr := &http.Transport{}
+	client := &http.Client{Transport: tr}
+	c := make(chan error, 1)
+	go func() { c <- f(client.Do(req)) }()
+	select {
+	case <-ctx.Done():
+		tr.CancelRequest(req)
+		<-c // Wait for f to return.
+		return ctx.Err()
+	case err := <-c:
+		return err
+	}
+}
diff --git a/context/google_demo/server.go b/context/google_demo/server.go
@@ -0,0 +1,97 @@
+// The server program issues Google search requests and demonstrates the use of
+// the go.net Context API. It serves on port 8080.
+//
+// The /search endpoint accepts these query params:
+//   q=the Google search query
+//   timeout=a timeout for the request, in time.Duration format
+//
+// For example, http://localhost:8080/search?q=golang&timeout=1s serves the
+// first few Google search results for "golang" or a "deadline exceeded" error
+// if the timeout expires.
+package main
+
+import (
+	"context"
+	"html/template"
+	"learn-golang/context/google_demo/google"
+	"learn-golang/context/google_demo/userip"
+	"log"
+	"net/http"
+	"time"
+)
+
+func main() {
+	http.HandleFunc("/search", handleSearch)
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+// handleSearch handles URLs like /search?q=golang&timeout=1s by forwarding the
+// query to google.Search. If the query param includes timeout, the search is
+// canceled after that duration elapses.
+func handleSearch(w http.ResponseWriter, req *http.Request) {
+	// ctx is the Context for this handler. Calling cancel closes the
+	// ctx.Done channel, which is the cancellation signal for requests
+	// started by this handler.
+	var (
+		ctx    context.Context
+		cancel context.CancelFunc
+	)
+	timeout, err := time.ParseDuration(req.FormValue("timeout"))
+	if err == nil {
+		// The request has a timeout, so create a context that is
+		// canceled automatically when the timeout expires.
+		ctx, cancel = context.WithTimeout(context.Background(), timeout)
+	} else {
+		ctx, cancel = context.WithCancel(context.Background())
+	}
+	defer cancel() // Cancel ctx as soon as handleSearch returns.
+
+	// Check the search query.
+	query := req.FormValue("q")
+	if query == "" {
+		http.Error(w, "no query", http.StatusBadRequest)
+		return
+	}
+
+	// Store the user IP in ctx for use by code in other packages.
+	userIP, err := userip.FromRequest(req)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	ctx = userip.NewContext(ctx, userIP)
+
+	// Run the Google search and print the results.
+	start := time.Now()
+	results, err := google.Search(ctx, query)
+	elapsed := time.Since(start)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if err := resultsTemplate.Execute(w, struct {
+		Results          google.Results
+		Timeout, Elapsed time.Duration
+	}{
+		Results: results,
+		Timeout: timeout,
+		Elapsed: elapsed,
+	}); err != nil {
+		log.Print(err)
+		return
+	}
+}
+
+var resultsTemplate = template.Must(template.New("results").Parse(`
+<html>
+<head/>
+<body>
+  <ol>
+  {{range .Results}}
+    <li>{{.Title}} - <a href="{{.URL}}">{{.URL}}</a></li>
+  {{end}}
+  </ol>
+  <p>{{len .Results}} results in {{.Elapsed}}; timeout {{.Timeout}}</p>
+</body>
+</html>
+`))
diff --git a/context/google_demo/userip/userip.go b/context/google_demo/userip/userip.go
@@ -0,0 +1,49 @@
+// Package userip provides functions for extracting a user IP address from a
+// request and associating it with a Context.
+//
+// This package is an example to accompany https://blog.golang.org/context.
+// It is not intended for use by others.
+package userip
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+)
+
+// FromRequest extracts the user IP address from req, if present.
+func FromRequest(req *http.Request) (net.IP, error) {
+	ip, _, err := net.SplitHostPort(req.RemoteAddr)
+	if err != nil {
+		return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
+	}
+
+	userIP := net.ParseIP(ip)
+	if userIP == nil {
+		return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
+	}
+	return userIP, nil
+}
+
+// The key type is unexported to prevent collisions with context keys defined in
+// other packages.
+type key int
+
+// userIPkey is the context key for the user IP address.  Its value of zero is
+// arbitrary.  If this package defined other context keys, they would have
+// different integer values.
+const userIPKey key = 0
+
+// NewContext returns a new Context carrying userIP.
+func NewContext(ctx context.Context, userIP net.IP) context.Context {
+	return context.WithValue(ctx, userIPKey, userIP)
+}
+
+// FromContext extracts the user IP address from ctx, if present.
+func FromContext(ctx context.Context) (net.IP, bool) {
+	// ctx.Value returns nil if ctx has no value for the key;
+	// the net.IP type assertion returns ok=false for nil.
+	userIP, ok := ctx.Value(userIPKey).(net.IP)
+	return userIP, ok
+}
