CCA Handler

[yousifnimah]

Can CCA be handled within the same concurrency as CCR?

    _, err := m.WriteTo(App.Conn)   
    // Getting CCA here

[yousifnimah]

I've solved this issue using channels. I've made a channels manager that allows declaring, sending, and receiving dynamically.

Here is the solution:

Usage:

         _, err := m.WriteTo(App.Conn)

    ChManager.CreateChannel(SessionID)
    defer ChManager.CloseCh(SessionID)
    Result := ChManager.ReceiveData(SessionID)

ChanManager.go

package DaimApp

import (
    "fmt"
    "sync"
)

type ChannelManager struct {
    channels map[string]chan string
    mutex    sync.Mutex
}

func NewChannelManager() *ChannelManager {
    return &ChannelManager{
        channels: make(map[string]chan string),
    }
}

func (cm *ChannelManager) CreateChannel(id string) chan string {
    ch := make(chan string)
    cm.channels[id] = ch

    return ch
}

func (cm *ChannelManager) SendData(id, data string) {
    cm.mutex.Lock()
    defer cm.mutex.Unlock()

    ch, ok := cm.channels[id]
    if !ok {
        fmt.Println("Channel not found for ID:", id)
        return
    }

    ch <- data
}

func (cm *ChannelManager) ReceiveData(id string) string {
    ch, ok := cm.channels[id]
    if !ok {
        fmt.Println("Channel not found for ID:", id)
        return ""
    }

    data := <-ch
    return data
}

func (cm *ChannelManager) CloseCh(id string) {
    cm.mutex.Lock()
    defer cm.mutex.Unlock()

    ch, ok := cm.channels[id]
    if !ok {
        fmt.Println("Channel not found for ID:", id)
        return
    }
    close(ch)
    delete(cm.channels, id)
}