Method HandleRegisterHTTP

kontrol/http.go:52–232

(rw http.ResponseWriter, req *http.Request)

}

func (k *Kontrol) HandleRegisterHTTP(rw http.ResponseWriter, req *http.Request) {
	var args protocol.RegisterArgs

	if err := json.NewDecoder(req.Body).Decode(&args); err != nil {
		errMsg := fmt.Errorf("wrong register input: '%s'", err)
		http.Error(rw, jsonError(errMsg), http.StatusBadRequest)
		return
	}

	k.log.Info("Register (via HTTP) request from: %s", args.Kite)

	// Only accept requests with kiteKey, because that's the only way one can
	// register itself to kontrol.
	if args.Auth.Type != "kiteKey" {
		err := fmt.Errorf("unexpected authentication type: %s", args.Auth.Type)
		http.Error(rw, jsonError(err), http.StatusBadRequest)
		return
	}

	// empty url is useless for us
	if args.URL == "" {
		err := errors.New("empty URL")
		http.Error(rw, jsonError(err), http.StatusBadRequest)
		return
	}

	// decode and authenticated the token key. We'll get the authenticated
	// username
	username, err := k.Kite.AuthenticateSimpleKiteKey(args.Auth.Key)
	if err != nil {
		http.Error(rw, jsonError(err), http.StatusUnauthorized)
		return
	}
	args.Kite.Username = username

	ex := &kitekey.Extractor{
		Claims: &kitekey.KiteClaims{},
	}

	t, err := jwt.ParseWithClaims(args.Auth.Key, ex.Claims, ex.Extract)
	if err != nil {
		http.Error(rw, jsonError(err), http.StatusBadRequest)
		return
	}

	var keyPair *KeyPair
	resp := &protocol.RegisterResult{
		URL:               args.URL,
		HeartbeatInterval: int64(HeartbeatInterval / time.Second),
	}

	// check if the key is valid and is stored in the key pair storage, if not
	// found we don't allow to register anyone.
	r := &kite.Request{
		Username: username,
		Auth: &kite.Auth{
			Type: args.Auth.Type,
			Key:  args.Auth.Key,