[Bug] iter: resolve message: invalid message 8

[674316]

Describe the bug

All files will be downloaded to 'downloads' dir Error: callback: github.com/gotd/td/telegram.(*Client).Run.func3 github.com/gotd/[email protected]/telegram/connect.go:151

• iter: github.com/iyear/tdl/core/downloader.(*Downloader).Download github.com/iyear/tdl/[email protected]/downloader/downloader.go:59
• resolve message: github.com/iyear/tdl/app/dl.(*iter).process github.com/iyear/tdl/app/dl/iter.go:158
• invalid message 8: github.com/iyear/tdl/core/util/tutil.GetSingleMessage github.com/iyear/tdl/[email protected]/util/tutil/tutil.go:185

To Reproduce

./tdl dl -f tdl-export.json \
--template "{{ .FileCaption }}_{{ .FileName }}" --continue --skip-same tdl --pool 0 --proxy http://localhost:7890

Expected behavior

down

Version

Version: 0.17.0 Commit: 95120c0 Date: 2024-04-21T14:07:16Z

go1.21.9 darwin/arm64

Which OS are you running tdl on?

macOS

Additional context

·

[iyear]

I need more details to debug. Such as screenshot.

[saga420]

@iyear @674316

I'm encountering the same issue. When a message has been deleted, the tutil.GetSingleMessage function returns an error. While the error itself is expected, the issue lies in the following function:

File: app/dl/iter.go

func (i *iter) process(ctx context.Context) (ret bool, skip bool) {
    ........
    message, err := tutil.GetSingleMessage(ctx, i.pool.Default(ctx), peer, msg)
    if err != nil {
        i.err = errors.Wrap(err, "resolve message") 
        return false, false // The second 'false' should be 'true', otherwise tdl will get stuck on this deleted message
        // We need to continue next here
    }
  ........
}

I have updated this function and it works great.

func (i *iter) process(ctx context.Context) (ret bool, skip bool) {
	i.mu.Lock()
	defer i.mu.Unlock()

	defer func() {
		if i.j++; i.i < len(i.dialogs) && i.j >= len(i.dialogs[i.i].Messages) {
			i.i++
			i.j = 0
		}
	}()

	// end of iteration or error occurred
	if i.i >= len(i.dialogs) || i.j >= len(i.dialogs[i.i].Messages) || i.err != nil {
		return false, false
	}

	peer, msg := i.dialogs[i.i].Peer, i.dialogs[i.i].Messages[i.j]

	// check if finished
	if _, ok := i.finished[i.ij2n(i.i, i.j)]; ok {
		return false, true
	}

	from, err := i.manager.FromInputPeer(ctx, peer)
	if err != nil {
		i.err = errors.Wrap(err, "resolve from input peer")
		return false, false
	}
	message, err := tutil.GetSingleMessage(ctx, i.pool.Default(ctx), peer, msg)
	if err != nil {
		// i.err = errors.Wrap(err, "resolve message")
		log.Printf("resolve message %d/%d: %v", from.ID(), msg, err)
		return false, true 
	}

	if _, ok := message.GetGroupedID(); ok && i.opts.Group {
		return i.processGrouped(ctx, message, from)
	}
	return i.processSingle(message, from)
}