// getUpdates call can take before the bot gives it up.
telegramPollSlack = 20 * time.Second
+ // telegramPollTimeout is how long one getUpdates call can take.
+ telegramPollTimeout = telegramPollSeconds*time.Second + telegramPollSlack
+
// telegramSendTimeout is how long a sendMessage, sendRichMessage, or
// sendChatAction call can take. A connection that stops without a
// close, such as after a network change, then fails the call, and the
telegramAnswerBytes = 16 << 20
)
-// errTelegramNetwork tells that a Bot API call got no valid answer, such as
-// after a network error. A later call can work.
-var errTelegramNetwork = errors.New("no valid answer from the Bot API")
-
// newTelegramAPI returns the client of the Bot API at base with token.
func newTelegramAPI(base, token string) *TelegramAPI {
return &TelegramAPI{
// after a network error, HTTP 429, or a server error. It returns the wait that
// the Bot API asks for, or 0.
func telegramRetryable(err error) (bool, time.Duration) {
- if errors.Is(err, errTelegramNetwork) {
+ var network *TelegramNetworkError
+
+ if errors.As(err, &network) {
return true, 0
}
var answer *TelegramError
+
if errors.As(err, &answer) {
return answer.Status == http.StatusTooManyRequests || answer.Status >= 500, answer.RetryAfter
}
// tell this, so it is not a refusal.
func telegramRejected(err error) bool {
var answer *TelegramError
+
return errors.As(err, &answer) && answer.Refused && (answer.Status == http.StatusBadRequest || answer.Status == http.StatusNotFound)
}
// TelegramAPI calls the Telegram Bot API. The bot token is a part of each URL,
-// so no error of TelegramAPI holds a URL, a net/http error, or the token.
-// SendTimeout limits each sendMessage, sendRichMessage, and sendChatAction
-// call.
+// so no error of TelegramAPI holds a URL, a net/http error, or the token. Its
+// sendTimeout field limits each sendMessage, sendRichMessage, and
+// sendChatAction call.
type TelegramAPI struct {
base string
token string
// and returns them. Telegram forgets each update before offset. Only new
// messages are asked for.
func (b *TelegramAPI) GetUpdates(ctx context.Context, offset int64) ([]TelegramUpdate, error) {
- ctx, cancel := context.WithTimeout(ctx, telegramPollSeconds*time.Second+telegramPollSlack)
- defer cancel()
-
var updates []TelegramUpdate
- err := b.call(ctx, "getUpdates", map[string]any{
+
+ err := b.call(ctx, telegramPollTimeout, "getUpdates", map[string]any{
"offset": offset,
"timeout": telegramPollSeconds,
"allowed_updates": []string{"message"},
// SendMessage sends text to chat with the format of entities, with no parse
// mode, so the text needs no escaping. With no entities, the text is plain. A
-// call that takes longer than telegramSendTimeout fails with
-// errTelegramNetwork.
+// call that takes longer than telegramSendTimeout fails with a
+// TelegramNetworkError.
func (b *TelegramAPI) SendMessage(ctx context.Context, chat int64, text string, entities []TelegramEntity) error {
- ctx, cancel := context.WithTimeout(ctx, b.sendTimeout)
- defer cancel()
-
params := map[string]any{
"chat_id": chat,
"text": text,
params["entities"] = entities
}
- return b.call(ctx, "sendMessage", params, nil)
+ return b.call(ctx, b.sendTimeout, "sendMessage", params, nil)
}
// SendRichMessage sends markdown to chat as a rich message, which Telegram
// renders itself, tables included. A call that takes longer than
-// telegramSendTimeout fails with errTelegramNetwork.
+// telegramSendTimeout fails with a TelegramNetworkError.
func (b *TelegramAPI) SendRichMessage(ctx context.Context, chat int64, markdown string) error {
- ctx, cancel := context.WithTimeout(ctx, b.sendTimeout)
- defer cancel()
-
- return b.call(ctx, "sendRichMessage", map[string]any{
+ return b.call(ctx, b.sendTimeout, "sendRichMessage", map[string]any{
"chat_id": chat,
"rich_message": map[string]any{
"markdown": markdown,
}
// SendTyping shows the typing action in chat for about five seconds. A call
-// that takes longer than telegramSendTimeout fails with errTelegramNetwork.
+// that takes longer than telegramSendTimeout fails with a TelegramNetworkError.
func (b *TelegramAPI) SendTyping(ctx context.Context, chat int64) error {
- ctx, cancel := context.WithTimeout(ctx, b.sendTimeout)
- defer cancel()
-
- return b.call(ctx, "sendChatAction", map[string]any{
+ return b.call(ctx, b.sendTimeout, "sendChatAction", map[string]any{
"chat_id": chat,
"action": "typing",
}, nil)
}
// call sends one call of method with the JSON params and decodes its result
-// into result, when result is not nil.
-func (b *TelegramAPI) call(ctx context.Context, method string, params, result any) error {
+// into result, when result is not nil. The call can take up to timeout. Its
+// errors tell the cause in plain words, with no method name, so that a log line
+// can say first what the call was for.
+func (b *TelegramAPI) call(ctx context.Context, timeout time.Duration, method string, params, result any) error {
+ ctx, cancel := context.WithTimeout(ctx, timeout)
+ defer cancel()
+
body, err := json.Marshal(params)
if err != nil {
return fmt.Errorf("%s: encode request: %w", method, err)
}
request.Header.Set("Content-Type", "application/json")
+
response, err := b.http.Do(request)
if err != nil {
- return fmt.Errorf("%s: %w: %s", method, errTelegramNetwork, b.redact(err))
+ return b.networkError("no answer", err, timeout)
}
data, err := io.ReadAll(io.LimitReader(response.Body, telegramAnswerBytes))
err = errors.Join(err, response.Body.Close())
if err != nil {
- return fmt.Errorf("%s: %w: read answer: %s", method, errTelegramNetwork, b.redact(err))
+ return b.networkError("answer cut off", err, timeout)
}
var answer TelegramAnswer
+
err = json.Unmarshal(data, &answer)
if err != nil && response.StatusCode != http.StatusOK {
return &TelegramError{
- Method: method,
Status: response.StatusCode,
Description: http.StatusText(response.StatusCode),
}
}
if err != nil {
- return fmt.Errorf("%s: %w: decode answer: %s", method, errTelegramNetwork, b.redact(err))
+ return b.networkError("invalid JSON", err, timeout)
}
if !answer.OK {
return &TelegramError{
- Method: method,
Status: response.StatusCode,
Description: b.redact(errors.New(answer.Description)),
RetryAfter: time.Duration(answer.Parameters.RetryAfter) * time.Second,
err = json.Unmarshal(answer.Result, result)
if err != nil {
- return fmt.Errorf("%s: %w: decode result: %s", method, errTelegramNetwork, b.redact(err))
+ return b.networkError("invalid result", err, timeout)
}
return nil
}
+// networkError returns the TelegramNetworkError of err, which happened at the
+// step that what names. When the call used all of its time timeout, the cause
+// is "no answer in TIMEOUT", because the Go text of a deadline does not tell
+// how long the wait was.
+func (b *TelegramAPI) networkError(what string, err error, timeout time.Duration) error {
+ if errors.Is(err, context.DeadlineExceeded) {
+ return &TelegramNetworkError{
+ Cause: "no answer in " + timeout.String(),
+ }
+ }
+
+ return &TelegramNetworkError{
+ Cause: what + ": " + b.redact(err),
+ }
+}
+
// redact returns the text of err without a URL and without the token. A
// *url.Error holds the URL of the call, which holds the token, so only its
// cause is kept.
func (b *TelegramAPI) redact(err error) string {
var urlError *url.Error
+
if errors.As(err, &urlError) {
err = urlError.Err
}
return strings.ReplaceAll(err.Error(), b.token, "TOKEN")
}
-// TelegramError is an answer of the Bot API that tells of a failure. RetryAfter
-// is the wait that the Bot API asks for after HTTP 429. Refused tells that the
-// answer is a Bot API answer with ok false, not a page of a proxy or of a
-// server error.
+// TelegramNetworkError tells that a Bot API call got no valid answer, such as
+// after a network error. A later call can work. Cause tells why in plain words,
+// with no URL and no token.
+type TelegramNetworkError struct {
+ Cause string
+}
+
+func (e *TelegramNetworkError) Error() string {
+ return e.Cause
+}
+
+// TelegramError is an answer of the Bot API that tells of a failure. Its text
+// gives the HTTP status and the description, such as "502 Bad Gateway".
+// RetryAfter is the wait that the Bot API asks for after HTTP 429. Refused
+// tells that the answer is a Bot API answer with ok false, not a page of a
+// proxy or of a server error.
type TelegramError struct {
- Method string
Status int
Description string
RetryAfter time.Duration
}
func (e *TelegramError) Error() string {
- return fmt.Sprintf("%s: Bot API answered %d: %s", e.Method, e.Status, e.Description)
+ return fmt.Sprintf("%d %s", e.Status, e.Description)
}
// TelegramUpdate is one update of getUpdates. Message is nil for the kinds of
projects / onechat / blobdiff