[SOLVED] Request is not returning results even though HTTP server is starting using Go and protobuf, SQL Server

Issue

I am trying to create a API request using Go, protobuf and SQL Server as my db. My HTTP server is starting by curl request is returning code: 5

My main.go code

package main

import (
    "context"
    "database/sql"
    "encoding/json"
    "fmt"
    "log"
    "net"
    "net/http"

    "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
    pb "github.com/myorg/nb_nb_nb/proto"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    _ "google.golang.org/grpc/grpclog/glogger"

    _ "github.com/denisenkom/go-mssqldb"
)

type appServer struct {
    pb.UnimplementedMyAppServiceServer
    db *sql.DB
}
//mssql
const (
    dbserver = "windows.net"
    port     = 1433
    user     = "reader"
    password = "mypassword"
    database = "dbnm"
)

const sqlQuery = `
my query
`

func (s *appServer) ExecuteQuery(ctx context.Context, req *pb.QueryRequest) (*pb.QueryResponseList, error) {
    log.Printf("received: Start Date - %v, End Date - %v", req.GetReportStartDate(), req.GetReportEndDate())

    rows, err := s.db.Query(sqlQuery, req.ReportStartDate, req.ReportEndDate)
    if err != nil {
        log.Printf("Error executing query: %v", err)
        return nil, fmt.Errorf("failed to execute query: %v", err)
    }
    defer rows.Close()

    var results []*pb.QueryResponse
    for rows.Next() {
        var result pb.QueryResponse
        err := rows.Scan(
            //fields
        )
        if err != nil {
            log.Printf("Error scanning rows: %v", err)
            return nil, fmt.Errorf("failed to scan rows: %v", err)
        }

        results = append(results, &result)
    }

    return &pb.QueryResponseList{Responses: results}, nil
}

func connectDB() (*sql.DB, error) {
    connectionString := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=%s", dbserver, user, password, port, database)
    db, err := sql.Open("mssql", connectionString)
    if err != nil {
        return nil, fmt.Errorf("failed to connect to the database: %v", err)
    }

    if err := db.Ping(); err != nil {
        return nil, fmt.Errorf("database connection failed: %v", err)
    }

    fmt.Println("Database connection successful")
    return db, nil
}

func main() {
    defer func() {
        if r := recover(); r != nil {
            log.Println("Recovered from panic:", r)
        }
    }()

    db, err := connectDB()
    if err != nil {
        log.Fatalf("Failed to connect to the database: %v", err)
    }
    defer db.Close()

    log.Println("Starting gRPC server...")
    lis, err := net.Listen("tcp", ":7777")
    if err != nil {
        log.Fatalf("TCP connection failed: %v", err)
    } else {
        log.Printf("gRPC Server Listening at %v", lis.Addr())
    }

    size := 1024 * 1024 * 50
    s := grpc.NewServer(grpc.MaxRecvMsgSize(size), grpc.MaxSendMsgSize(size))
    pb.RegisterMyAppServiceServer(s, &appServer{db: db})

    mux := runtime.NewServeMux()
    opts := []grpc.DialOption{grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, ""))}
    err = pb.RegisterMyAppServiceHandlerFromEndpoint(context.Background(), mux, ":7777", opts)
    if err != nil {
        log.Fatalf("Failed to register gRPC gateway: %v", err)
    } else {
        log.Printf("Registered gRPC gateway")
    }

    http.HandleFunc("/api/query", func(w http.ResponseWriter, r *http.Request) {
        startDate := r.URL.Query().Get("startDate")
        endDate := r.URL.Query().Get("endDate")

        req := &pb.QueryRequest{
            ReportStartDate: startDate,
            ReportEndDate:   endDate,
        }
        fmt.Print(req)
        resp, err := (&appServer{db: db}).ExecuteQuery(r.Context(), req)
        if err != nil {
            log.Printf("Error executing query: %v", err)
            http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            return
        }

        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(resp.Responses)
    })

    go func() {
        log.Println("Starting HTTP server...")
        err := http.ListenAndServe(":7778", mux)
        if err != nil {
            log.Fatalf("HTTP server failed: %v", err)
        } else {
            log.Printf("HTTP server started.")
        }
    }()

    if err := s.Serve(lis); err != nil {
        log.Fatalf("gRPC server failed: %v", err)
    } else {
        log.Printf("gRPC, HTTP, and API server started.")
    }
}

go run server/main.go returns

Database connection successful
2023/12/24 21:48:23 Starting gRPC server...
2023/12/24 21:48:23 gRPC Server Listening at [::]:7777
2023/12/24 21:48:23 Registered gRPC gateway
2023/12/24 21:48:23 Starting HTTP server...

and curl request(curl -X GET "http://localhost:7778/api/query?startDate=2023-10-01&endDate=2023-10-02") returns:

{"code":5, "message":"Not Found", "details":[]}

What is missing in my code? Why am I not able to get any results back? My firewall is off.

Solution

It seems like the route "/api/query" has been defined on the default ServeMux, but the mux ServeMux is used when listening on the interface.

Answered By - nameless6849

Answer Checked By - Cary Denson (WPSolving Admin)