Session lifetime and setting session active

[camuig]

Hi,

I use UpdateHandler to get updates. How can I manage session lifetime? Or maybe should I send something periodically to support current session? Also I realised I receive updates with delay. So is there any way to make current connection primary or active to get updates immediately?

Thanks in advance!

[ernado]

Client is using keep alive, so session should be live until explicit logout.

Not sure about updates delay, probably some complex logic on Telegram side, like "send updates to recently accessed entities faster" or something like that.

[camuig]

Thanks for quick reply!

Client is using keep alive, so session should be live until explicit logout.

I restart daemon every day after logrotate job and every second day it fails because code is needed. Is there some issue with session file? But it works every first day.

Not sure about updates delay, probably some complex logic on Telegram side, like "send updates to recently accessed entities faster" or something like that.

I've already tried to logout from all other devices but it didn't help. I think I should read how it works on the internet.

[ernado]

I restart daemon every day after logrotate job and every second day it fails because code is needed.

This is unexpected. Can you please provide a code snippet of client initialization?
Session storage should persist session and no code should be needed.

[camuig]

I used examples.

package main

import (
	"context"
	"errors"
	"flag"
	"github.com/gotd/td/session"
	"github.com/gotd/td/telegram"
	"github.com/gotd/td/telegram/auth"
	"github.com/gotd/td/telegram/updates"
	"github.com/gotd/td/telegram/updates/hook"
	"github.com/gotd/td/tg"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"os"
	"os/signal"
)

const (
	AppID     = 0
	AppHash   = ""
)

func main() {
	phone := flag.String("phone", "", "phone number to authenticate")
	sessionFile := flag.String("sessionfile", "", "path to session file")
	flag.Parse()
	log, _ := zap.NewDevelopment(zap.IncreaseLevel(zapcore.InfoLevel), zap.AddStacktrace(zapcore.FatalLevel))
	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
	defer cancel()
	if err := run(ctx, log, *phone, *sessionFile); err != nil {
		log.Fatal("Err", zap.Error(err))
	}
}

func run(ctx context.Context, log *zap.Logger, phone string, sessionFile string) error {
	defer func() { _ = log.Sync() }()
	gaps := updates.New(updates.Config{
		Handler: telegram.UpdateHandlerFunc(func(ctx context.Context, u tg.UpdatesClass) error {
			for _, update := range u.(*tg.Updates).Updates {
				if upd, ok := update.(*tg.UpdateNewChannelMessage); ok {
					if mess, ok := upd.Message.(*tg.Message); ok {
						log.Info(
							"UpdateNewChannelMessage",
							zap.Int64("channel_id", mess.PeerID.(*tg.PeerChannel).ChannelID),
							zap.String("message", mess.Message),
						)
					}
				}

				if upd, ok := update.(*tg.UpdateNewMessage); ok {
					if mess, ok := upd.Message.(*tg.Message); ok {
						log.Info(
							"UpdateNewMessage",
							zap.Int64("user_id", mess.FromID.(*tg.PeerUser).UserID),
							zap.String("message", mess.Message),
						)
					}
				}
			}
			return nil
		}),
		Logger: log.Named("gaps"),
	})

	flow := auth.NewFlow(terminal_auth.TermAuth{
		PhoneNumber: phone,
	}, auth.SendCodeOptions{})
	client := telegram.NewClient(AppID, AppHash, telegram.Options{
		SessionStorage: &session.FileStorage{Path: sessionFile},
		UpdateHandler:  gaps,
		Logger:         log,
		Middlewares: []telegram.Middleware{
			hook.UpdateHook(gaps.Handle),
		},
	})

	return client.Run(ctx, func(ctx context.Context) error {
		if err := client.Auth().IfNecessary(ctx, flow); err != nil {
			return err
		}
		status, _ := client.Auth().Status(ctx)
		if !status.Authorized {
			return errors.New("not authenticated")
		}

		user, err := client.Self(ctx)
		if err != nil {
			return err
		}

		if err = gaps.Auth(ctx, client.API(), user.ID, user.Bot, true); err != nil {
			return err
		}
		defer func() { _ = gaps.Logout() }()

		<-ctx.Done()
		return ctx.Err()
	})
}

TermAuth is completely the same as in this example https://github.com/gotd/td/blob/main/examples/auth/main.go

[camuig]

I've solved it. It was my fault with session file.
I'm sorry for disturbing you. Thanks for help!