Method sendHeartbeats

heartbeat.go:185–243

(interval time.Duration, kiteURL *url.URL)

var errRegisterAgain = errors.New("register again")

func (k *Kite) sendHeartbeats(interval time.Duration, kiteURL *url.URL) {
	heartbeatURL := k.getKontrolPath("heartbeat")

	k.Log.Debug("Starting to send heartbeat to: %s", heartbeatURL)

	u, err := url.Parse(heartbeatURL)
	if err != nil {
		k.Log.Fatal("HeartbeatURL is malformed: %s", err)
	}

	q := u.Query()
	q.Set("id", k.Id)
	u.RawQuery = q.Encode()

	heartbeatFunc := func() error {
		k.Log.Debug("Sending heartbeat to %s", u)

		resp, err := k.Config.Client.Get(u.String())
		if err != nil {
			return err
		}
		defer resp.Body.Close()

		if resp.StatusCode != http.StatusOK {
			return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
		}

		// we are just receiving small size strings such as "pong",
		// "registeragain" so we limit the reader to read just that
		p, err := ioutil.ReadAll(io.LimitReader(resp.Body, 16))
		if err != nil {
			return err
		}

		p = bytes.TrimSpace(p)

		k.Log.Debug("Heartbeat response received %q", p)

		switch string(p) {
		case "pong":
			return nil
		case "registeragain":
			k.Log.Info("Disconnected from Kontrol, going to register again")

			go func() {
				k.RegisterHTTPForever(kiteURL)
			}()

			return errRegisterAgain
		}

		return fmt.Errorf("malformed heartbeat response: %s", p)
	}

	k.heartbeatC <- &heartbeatReq{
		ping:     heartbeatFunc,
		interval: interval,
	}