Golang channel.Create函数代码示例

func AddClient(c appengine.Context, id string) (string, os.Error) {

	q := datastore.NewQuery("Client")
	var gg []*Client
	var check = 0

	if _, err := q.GetAll(c, &gg); err != nil {
		return "", err
	}

	for _, client := range gg {
		if client.ClientID == id {
			check = check + 1
		}
	}

	if check == 0 {
		key := datastore.NewIncompleteKey("Client")
		client := Client{ClientID: id}

		_, err := datastore.Put(c, key, &client)
		if err != nil {
			return "", err
		}
	}

	memcache.Delete(c, "sut")

	return channel.Create(c, id)

}

func idhandler(w http.ResponseWriter, r *http.Request) {
	c = appengine.NewContext(r)
	clientID := strconv.Itoa(rand.Int())

	// add nick to db
	keysCache := &memcache.Item{
		Key:   clientID,
		Value: []byte(r.FormValue("nick")),
	}
	memcache.Set(c, keysCache)
	// add user to list
	userList := getUserList()
	if !stringInSlice(clientID, userList) {
		keys := append(userList, clientID)
		setUserList(keys)
	}
	// create channel
	tok, _ := channel.Create(c, clientID)
	responseList := []map[string]string{{"tok": tok, "id": clientID}}
	for _, id := range userList {
		nick := getNick(id)
		responseList = append(responseList, map[string]string{"nick": nick, "id": id})
	}
	response, _ := json.Marshal(responseList)
	fmt.Fprint(w, string(response))
}

func GetToken(c appengine.Context, h *hunt.Hunt, t *team.Team, admin bool) string {
	// Channel name format: huntID.timestamp
	timestamp := fmt.Sprintf("%d", time.Now().UnixNano())
	channelName := fmt.Sprintf("%s.%s", h.ID, timestamp)
	token, err := channel.Create(c, channelName)
	if err != nil {
		c.Errorf("Error: %v", err)
		return ""
	}
	listener := Listener{
		Channel:   channelName,
		Timestamp: timestamp,
		Admin:     admin,
		Open:      false,
	}
	if t != nil {
		listener.TeamID = t.ID
	}
	_, err = datastore.Put(c, datastore.NewIncompleteKey(c, listenerKind, h.Key), &listener)
	if err != nil {
		c.Errorf("Error: %v", err)
		return ""
	}
	return token
}

// Make a client of the specified dinger and return the id and token associated with the new client.
func MakeClient(c appengine.Context, dingerKey *datastore.Key) (*Client, os.Error) {
	// Create a key for this client
	key := datastore.NewKey(CLIENT_KEY_KIND, "", 0, dingerKey)

	// Generate some id for the client. It'll be the SHA1 sum of the dinger id and some random number.
	hashWriter := sha1.New()
	fmt.Fprint(hashWriter, KeyToDingerId(dingerKey))

	// Append a random integer
	randId, err := rand.Int(rand.Reader, big.NewInt(0x7fffffffffffffff))
	if err != nil {
		return nil, err
	}
	fmt.Fprint(hashWriter, randId)

	// Base64 encode the client id
	id := base64.URLEncoding.EncodeToString(hashWriter.Sum())

	// Create a channel for this client.
	tok, err := channel.Create(c, id)
	if err != nil {
		return nil, err
	}

	// Create the client record and store it
	client := &Client{Id: id, Token: tok}
	key, err = datastore.Put(c, key, client)
	if err != nil {
		return nil, err
	}

	return client, nil
}

func goToGame(w http.ResponseWriter, r *http.Request) {
	g, err := poker.LoadGame(r.FormValue("id"), r)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	c := appengine.NewContext(r)
	u := user.Current(c)
	tok, err := channel.Create(c, u.Email+g.Id())
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if addWatcher(g, u.Email) {
		err := g.Save(r)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	}
	json, err := g.ClientState(u.Email).JSON()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	defineNames(w)
	if err := gameTemplate.Execute(w, json); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
	fmt.Fprintf(w, "<script>channel('%s')</script>", tok)
}

func root(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	clientTemplate := template.Must(template.ParseFile("client.html"))
	token_value := strconv.Itoa(rand.Int())
	token_key, _ := channel.Create(c, token_value)
	clientTemplate.Execute(w, token_key)
	map_clients[token_key] = token_value
}

func getchannel(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	tok, err := channel.Create(c, "hotload")
	if err != nil {
		// handle error
	}
	// return token to the client in an HTTP response
	fmt.Fprintln(w, tok)
}

func initChannel(pfc *PFContext) (interface{}, error) {
	if pfc.ChannelID == "" {
		return nil, NewReadableError(_l("Missing Client ID"), nil)
	}

	if token, err := channel.Create(pfc.C, pfc.ChannelID); err != nil {
		return nil, NewReadableError(_l("Error initializing channel"), &err)
	} else {
		return map[string]string{"token": token}, nil
	}
}

func handleCreateChannel(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	token, err := channel.Create(c, "placeholder")
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}

	w.Header().Set("Content-type", "text/json; charset=utf-8")
	jsonEncoder := json.NewEncoder(w)
	jsonEncoder.Encode(CreateChannelResponse{token})
}

func connect(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	users++
	id := strconv.Itoa(users)
	tok, err := channel.Create(c, id)
	if err != nil {
		http.Error(w, "Couldn't create Channel", http.StatusInternalServerError)
		c.Errorf("channel.Create: %v", err)
		return
	}
	payload, _ := json.Marshal(map[string]string{"me": id, "token": tok})
	fmt.Fprint(w, string(payload))
}

// AddClient puts a Client record to the datastore with the Room as its
// parent, creates a channel and returns the channel token.
func (r *Room) AddClient(c appengine.Context, id string) (string, error) {
	key := datastore.NewKey(c, "Client", id, 0, r.Key(c))
	client := &Client{id}
	_, err := datastore.Put(c, key, client)
	if err != nil {
		return "", err
	}

	// Purge the now-invalid cache record (if it exists).
	memcache.Delete(c, r.Name)

	return channel.Create(c, id)
}

func handleWrPage(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	queryMap := r.URL.Query()
	table := queryMap.Get("t")
	id := queryMap.Get("u")
	token, err := channel.Create(c, table+"-"+id)
	err = tableTemplate.Execute(w, map[string]string{
		"userToken": token,
	})
	if err != nil {
		c.Errorf("tableTemplate: %v", err)
	}
}

func interview_create(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	tok, err := channel.Create(c, r.FormValue("id"))
	callback := r.FormValue("callback")
	if err != nil {
		http.Error(w, "Couldn't create Channel", http.StatusInternalServerError)
		c.Errorf("channel.Create: %v", err)
		return
	}
	if callback == "" {
		callback = "callback"
	}
	fmt.Fprintf(w, callback+"('%s')", tok)
}

func whiteboardHandler(w http.ResponseWriter, r *http.Request) {
	vm := NewWhiteboardVM()
	c := appengine.NewContext(r)

	code := r.FormValue("x")
	repo := repository.NewRepo(c)
	candidate, interviewer, err := repo.GetSession(code)

	if err != nil {
		c.Errorf("repo.GetSession: %v", err)
		http.Redirect(w, r, "/", http.StatusMovedPermanently)
		return
	}

	vm.Candidate, vm.Interviewer = candidate, interviewer

	tc := twilio.NewTwilioCapability(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)

	vm.IsInterviewer = (code == interviewer)
	if vm.IsInterviewer {
		vm.Message = "Interviewer mode."
		tc.AllowClientOutgoing(TWILIO_APP_SID, nil)
	} else {
		vm.Message = "Candidate mode."
		tc.AllowClientIncoming(candidate)
	}

	tokenExpiration := time.Duration(48) * time.Hour

	twilioToken, err := tc.Generate(tokenExpiration)

	if err != nil {
		c.Errorf("capability.Generate: %s", err)
		http.Error(w, "Twilio setup error.", http.StatusInternalServerError)
		return
	}
	vm.TwilioToken = twilioToken

	// Create channel token.
	tok, err := channel.Create(c, code)
	if err != nil {
		c.Errorf("template.ParseSetFiles: %s", err)
		http.Error(w, "Channel error.", http.StatusInternalServerError)
		return
	}
	vm.ChannelToken = tok

	renderPage(w, c, "view/whiteboard.html", vm)
}

func OnToken(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	roomName := r.FormValue("room")
	if roomName != "" {
		userName := Random(10)
		clientId := MakeClientId(roomName, userName)
		token, err := channel.Create(c, clientId)
		if err != nil {
			c.Criticalf("Error while creating token: %s", err)
		}
		w.Write([]byte("user=" + userName + "&token=" + token))
	} else {
		w.WriteHeader(http.StatusBadRequest)
	}
}