Updating the view with asynchronous messages

[c-grimshaw]

First of all, I just want to say that this library is incredible. I'm having so much fun writing my first project using this tooling. I can't understate how amazing the codebase is.

I'm currently writing a tcpdump-esque TUI, and I think I've achieved the minimum level of functionality-- that is, a user can select their network interface, specify a packet filter, and the packets start streaming into a viewport.

However, I'm not sure if I'm updating the viewport properly, as it feels a bit... Janky.

case key.Matches(msg, DefaultKeyMap.Enter):
    if m.submitFieldFocused() {
        if !m.recording {
	    m.recording = !m.recording
	    go m.start()
        }
}

I call a method that starts recording filtered packets on an interface. Inside the start method...

func (m *model) start() {
...
    for packet := range source.Packets() {
        m.Update(Process(packet))
    }
}

With source.Packets() being a channel, receiving packets as they come in.

Next, using the Process and (m *model) Update functions....

func Process(packet gopacket.Packet) tea.Msg { return packetMsg(packet.String()) }
---
func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
...
	case packetMsg:
		m.content += msg.String() + "\n"
		m.viewport.SetContent(m.content)
		m.viewport, cmd = m.viewport.Update(msg)
		m.viewport.GotoBottom()
		cmds = append(cmds, cmd)
.

Does that.... Seem right? Calling m.Update() inside the start method and passing it the packet feels strange. My understanding of Commands are definitely shakey, and I've moved far enough into this hobby project that I'd like to understand the flow of data better.

Thank you very much for the pleasure of using these tools. Again, huge fan.

[c-grimshaw]

After doing some more research, I think the answer is using channels to communicate, as seen in this example.

[c-grimshaw]

Well, just for the sake of completion, (and I understand this is an echo chamber), that example was indeed the solution.

The changes I made:

1. The model now contains a channel for incoming packets;
2. The Update() function now returns a command that listens for incoming packets:

func waitForPacket(packet chan gopacket.Packet) tea.Cmd {
	return func() tea.Msg {
		return packetMsg((<-packet).String())
	}
}

3. Packets are sent to the model in a very simple select loop:

for {
    select {
    case packet := <-source.Packets():
	    m.packetChan <- packet
    case <-m.stopChan:
	    return
    }
}

Definitely untangled my usage of commands and learned a lot in the process. I recognize that I am emphatically talking to myself, but I'd also like to say thanks to the kind charmbracelet soul who gave my repo my first ever Star, haha.

Thank you again.

[bashbunni]

Ah so glad you found a solution! GOSNIFF is awesome 😄

[c-grimshaw]

Canadian maintainer?! Love to see it. Thank you so much! It absolutely does not deserve the current amount of stars lmao