Golang http.Conn類代碼示例

// Symbol looks up the program counters listed in the request,
// responding with a table mapping program counters to function names.
// The package initialization registers it as /debug/pprof/symbol.
func Symbol(c *http.Conn, r *http.Request) {
	c.SetHeader("content-type", "text/plain; charset=utf-8")

	// We don't know how many symbols we have, but we
	// do have symbol information.  Pprof only cares whether
	// this number is 0 (no symbols available) or > 0.
	fmt.Fprintf(c, "num_symbols: 1\n")

	var b *bufio.Reader
	if r.Method == "POST" {
		b = bufio.NewReader(r.Body)
	} else {
		b = bufio.NewReader(strings.NewReader(r.URL.RawQuery))
	}

	for {
		w, err := b.ReadSlice('+')
		if err == nil {
			w = w[0 : len(w)-1] // trim +
		}
		pc, _ := strconv.Btoui64(string(w), 0)
		if pc != 0 {
			f := runtime.FuncForPC(uintptr(pc))
			if f != nil {
				fmt.Fprintf(c, "%#x %s\n", pc, f.Name())
			}
		}

		// Wait until here to check for err; the last
		// symbol will have an err because it doesn't end in +.
		if err != nil {
			break
		}
	}
}

func TWITTER_REPLIES(c *http.Conn, req *http.Request) {
	log.Stderrf(">REPLIES:");
	s := session_service.GetSession(c,req);
	for k,v := range s.Data {
		log.Stderrf("session kv:%s:%s", k, v);
	}
	auth_token, atx := s.Data["oauth_token"];
	if atx {
		log.Stderrf("TOKEN FOUND!");
		auth_token_secret := s.Data["oauth_token_secret"];
		r, finalUrl, err := twitter_client.MakeRequest("http://twitter.com/statuses/mentions.json", map[string]string{"oauth_token":auth_token}, auth_token_secret, false); //{"since_id":s.last_reply_id})
		if err != nil {
			log.Stderrf(":REPLIES:err:%s",err);
		}
		else {
			log.Stderrf(":REPLIES:r:%s:finalUrl:%s", r, finalUrl);
			b, _ := io.ReadAll(r.Body);
			print ("REPLIES!");
			str := bytes.NewBuffer(b).String();
       			println (str);
			j, ok, errtok := json.StringToJson(str);
			log.Stderr("REPLIES:j:%s:ok:%s:errtok:%s", j, ok, errtok);
			c.Write(strings.Bytes(j.String()));
		}
	
	}
	else {
		log.Stderrf("NO TOKEN FOUND!");
		http.Redirect(c, "/login/twitter?returnto=/twitter/replies", http.StatusFound); // should be 303 instead of 302?
	}
}

// exec a program, redirecting output
func DateServer(c *http.Conn, req *http.Request) {
	c.SetHeader("content-type", "text/plain; charset=utf-8")
	r, w, err := os.Pipe()
	if err != nil {
		fmt.Fprintf(c, "pipe: %s\n", err)
		return
	}
	pid, err := os.ForkExec("/bin/date", []string{"date"}, os.Environ(), "", []*os.File{nil, w, w})
	defer r.Close()
	w.Close()
	if err != nil {
		fmt.Fprintf(c, "fork/exec: %s\n", err)
		return
	}
	io.Copy(c, r)
	wait, err := os.Wait(pid, 0)
	if err != nil {
		fmt.Fprintf(c, "wait: %s\n", err)
		return
	}
	if !wait.Exited() || wait.ExitStatus() != 0 {
		fmt.Fprintf(c, "date: %v\n", wait)
		return
	}
}

func Send(c *http.Conn, req *http.Request) {
	query_params, _ := http.ParseQuery(req.URL.RawQuery)
	arg_game, ok_game := query_params["game"]
	arg_msg, ok_msg := query_params["msg"]
	if !ok_game {
		c.Write([]byte("Game parameter not set"))
		return
	}
	if !ok_msg {
		c.Write([]byte("Msg parameter not set"))
		return
	}
	game := arg_game[0]
	msg := arg_msg[0]
	params := strings.Split(game, ",", 2)
	if len(params) != 2 {
		c.Write([]byte("Malformed game parameter"))
		return
	}
	game_id, player_id := params[0], params[1]
	game_instance := room.Find(game_id)
	if room == nil {
		c.Write([]byte("Game not found"))
		return
	}
	result := game_instance.Send(player_id, msg)
	c.Write([]byte(result))
}

func serveHTMLDoc(c *http.Conn, r *http.Request, path string) {
	// get HTML body contents
	src, err := ioutil.ReadFile(path)
	if err != nil {
		log.Stderrf("%v", err)
		http.NotFound(c, r)
		return
	}

	// if it begins with "<!DOCTYPE " assume it is standalone
	// html that doesn't need the template wrapping.
	if bytes.HasPrefix(src, strings.Bytes("<!DOCTYPE ")) {
		c.Write(src)
		return
	}

	// if it's the language spec, add tags to EBNF productions
	if strings.HasSuffix(path, "go_spec.html") {
		var buf bytes.Buffer
		linkify(&buf, src)
		src = buf.Bytes()
	}

	title := commentText(src)
	servePage(c, title, "", src)
}

// url: /blog/entry/add
func AddEntry(c *http.Conn, req *http.Request) {
	req.ParseForm();
	heading, body := req.FormValue("heading"), req.FormValue("body");
	if len(heading) > 0 && len(body) > 0 {
		blog.AddEntry(heading, body)
	}
	c.SetHeader("Location", "/blog");
	c.WriteHeader(http.StatusFound);
}

func (s *Swif) handleError(code int, c *http.Conn) {
	switch code {
	case http.StatusBadRequest:
		c.WriteHeader(code)
		io.WriteString(c, "Invalid Request")
	default:
		c.WriteHeader(http.StatusBadRequest)
		io.WriteString(c, "Invalid Request")
	}
}

// hello world, the web server
func HelloServer(c *http.Conn, req *http.Request)
{
  var creq CRequest;
  creq.conn = c;
  creq.req = req;
  //fmt.Printf("%s\n", creq.req);
  var e os.Error;
  creq.rwc, creq.buf, e = c.Hijack();
  if (e!=nil) {}
  req_channel <- creq;
}

func FlagServer(c *http.Conn, req *http.Request) {
	c.SetHeader("content-type", "text/plain; charset=utf-8")
	fmt.Fprint(c, "Flags:\n")
	flag.VisitAll(func(f *flag.Flag) {
		if f.Value.String() != f.DefValue {
			fmt.Fprintf(c, "%s = %s [default = %s]\n", f.Name, f.Value.String(), f.DefValue)
		} else {
			fmt.Fprintf(c, "%s = %s\n", f.Name, f.Value.String())
		}
	})
}

func (s FileServer) ServeHTTP(c *http.Conn, req *http.Request) {
	content, err := ioutil.ReadFile(s.loc)
	if err != nil {
		log.Stderr(err)
	} else {
		// get mime type
		mimeType := mime.TypeByExtension(path.Ext(s.loc)) // TODO cache this
		c.SetHeader("Content-Type", mimeType)
		fmt.Fprintf(c, "%s", content)
	}
}

func TestCode2(c *http.Conn, req *http.Request) {
	dump, err := http.DumpRequest(req, true)
	if err != nil {
		io.WriteString(c, err.String())
		return
	}
	_, err = c.Write(dump)
	if err != nil {
		io.WriteString(c, err.String())
		return
	}
	log.Stdout(string(dump))
}

func Wait(c *http.Conn, req *http.Request) {
	query_params, _ := http.ParseQuery(req.URL.RawQuery)
	arg_owner_id, ok_owner_id := query_params["owner_id"]
	if ok_owner_id {
		fmt.Println("Create owner_id=", arg_owner_id)
		owner_id := arg_owner_id[0]
		game_id := room.Wait(owner_id)
		fmt.Println("Create ", game_id)
		c.Write([]byte(game_id))
	} else {
		c.Write([]byte("Parameters not specified correctly"))
	}
}

func Connect(c *http.Conn, req *http.Request) {
	query_params, _ := http.ParseQuery(req.URL.RawQuery)
	arg_owner, ok_owner := query_params["owner"]
	if ok_owner {
		fmt.Println("Connect owner=", arg_owner)
		owner := arg_owner[0]
		owner_id := room.Connect(owner)
		fmt.Println("Connected as ", owner_id)
		c.Write([]byte(owner_id))
	} else {
		c.Write([]byte("Parameters not specified correctly"))
	}
}

func expvarHandler(c *http.Conn, req *http.Request) {
	c.SetHeader("content-type", "application/json; charset=utf-8")
	fmt.Fprintf(c, "{\n")
	first := true
	for name, value := range vars {
		if !first {
			fmt.Fprintf(c, ",\n")
		}
		first = false
		fmt.Fprintf(c, "%q: %s", name, value)
	}
	fmt.Fprintf(c, "\n}\n")
}

// url: /blog/comment/add
func AddComment(c *http.Conn, req *http.Request) {
	req.ParseForm();
	entryIDString, text := req.FormValue("entry_id"), req.FormValue("text");
	if len(entryIDString) > 0 && len(text) > 0 {
		if entryID, parseErr := strconv.Atoi(entryIDString); parseErr == nil {
			if foundEntry := blog.FindEntry(entryID); foundEntry != nil {
				foundEntry.AddComment(text);
			}
		}
	}
	c.SetHeader("Location", "/blog/entry/" + entryIDString);
	c.WriteHeader(http.StatusFound);
}