Golang - API Server and Socket at the same time

default http server accepts connection on one "host:port" only

Answer depends on what protocol you are going to use to communicate via your sockets.

I suggest to do it this way: (much simplified)

1. Leave http.Server alone to serve your API (it implements protocols HTTP 1.*/2 so you dont need to worry about it)

2. Implement your own "MultiSocketServer", do to so:

   2.1 Implement GracefulListener (must implement net.Listener) (you need to shutdown your sockets when you dont need them anymore, right?)

   2.2 Implement MultiSocketServer.Serve(l GracefulListener) (hello http.Server.Serve() ) to serve individual connection (your protocol to communicate with client via sockets goes here. something like net.textproto will be easy to implement since you GracefulListener.Accept() will return net.Conn)

   2.3 Add methods MultiSocketServer.ListenAndServe(addr), MultiSocketServer.StopServe(l GracefulListener) to your MultiSocketServer

   type MultiSocketServer struct {
       listeners GracefulListener[] //or map?
   
       // lots of other stuff
   }
   
   
   // looks familiar? (http.Server.ListenAndServe) 
   func (s *MultiSocketServer) ListenAndServe(addr string) {
       ln, err := net.Listen("tcp", addr)
       graceful_listner = &GracefulListener(ln)
   
       s.listeners = append(s.listeners, graceful_listner)
   
       go s.Serve(graceful_listner)
       return graceful_listner
   }
   
   func (s *MultiSocketServer) StopServe(graceful_listner  GracefulListener) {
       graceful_listner.Stop()
       //pseudocode
       remove_listener_from_slice(s.listeners, graceful_listner)
   }
   

Ofcourse, you need to add error checking and mutex (propably) to guard MultiSocketServer.listeners to make it thread safe.

In your main() start your API http.Server, and initialize your MultiSocketServer. Now from your http.Handler/http.HandlerFunc of http.Server you should be able to call MultiSocketServer.ListenAndServe(addr) to listen and serve your sockets connections.

UPDATE based on question

however, I'm not sure to understand the part "In your main()". If I understand it good, you said I have my API, and after starting it, I initialize MultiSocketServer. But where? after the starting of my API? Or you mean it would be better that I use the logic of your code as an API? Every request trough a socket

BTW: updated MultiSocketServer.ListenAndServe to start Listen and return graceful_listner

func main() {
    //init MultiSocketServer
    multi_socket_server = &MultiSocketServer{} //nil for GracefulListener[] is fine for now, complex initialization will be added later
    // no listners yet, serves nothing

    // create new Handeler for your "socket requests"
    SocketRequestHandler := function(w http.ResponseWriter, r *http.Request) {
       // identify client, assign him an address to connect
       addr_to_listen := parse_request(r) //pseudocode

       listener := multi_socket_server.ListenAndServe(addr_to_listen)
       // TODO: handle errors
       // now your multi_socket_server listen to addr_to_listen and serves it with multi_socket_server.Serve method in its own goroutine
       // as i said MultiSocketServer.Serve method must implement your protocol (plaintext Reader/Writer on listener for now?)

       save_listener_in_context_or_whatever_you_like_to_track_it(listener) //pseudo
   }  

    SocketDisconnectHandler := function(w http.ResponseWriter, r *http.Request) {
      // identify client 
      some_client := parse_request(r) //pseudocode
      // get listener based on info
      listener := get_listener_from_context_or_whatever(some_client) //pseudo

      multi_socket_server.StopServe(listener)
      // TODO: handle errors
    }

    //initialize your API http.Server
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    r.HandleFunc("/products", ProductsHandler)
    r.HandleFunc("/articles", ArticlesHandler)
    r.HandleFunc("/socket_request", SocketRequestHandler) // added
    r.HandleFunc("/socket_disconnect", SocketDisconnectHandler) //added
    http.Handle("/", r)

    // it creates new http.Server with DefaultServeMux as Handler (which is configured with your http.Handle("/", r) call)
   http.ListenAndServe(":8080") // start serving API via HTTP proto
}

Actually, you may call multi_socket_server.ListenAndServe(addr_to_listen) and multi_socket_server.StopServe(listener) from any handler in your API server.

Every time you call multi_socket_server.ListenAndServe(addr_to_listen) it will create new listener and serve on it, you have to control it (dont listen on the same address more then once (i think it will error out anyway))

Your MultiSocketServer.Serve may looks like:

func (s *MultiSocketServer) Serve(l net.Listener) {
    defer l.Close()

    for {     
        // will listen for message to process ending in newline (\n)
        message, _ := bufio.NewReader(conn).ReadString('\n')
        // output message received     
        fmt.Print("Message Received:", string(message))
        // sample process for string received     
        newmessage := strings.ToUpper(message)
        // send new string back to client     
        conn.Write([]byte(newmessage + "\n"))   
    } 
}

Possible GracefulListener implementation github

Or are you trying to achieve something completely different? =)