Creating few REST API endpoints

cmd/discover.go

@@ -3,11 +3,16 @@ package cmd
 
 import (
 	"context"
+	"embed"
 	"errors"
+	"io/fs"
 	"net/http"
 	"time"
 
+	"github.com/go-chi/chi"
+	"github.com/go-chi/cors"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/shaharia-lab/teredix/pkg/api"
 	"github.com/shaharia-lab/teredix/pkg/config"
 	"github.com/shaharia-lab/teredix/pkg/metrics"
 	"github.com/shaharia-lab/teredix/pkg/processor"
@@ -19,6 +24,12 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// Embed the entire static directory. frontend/static directory is located under `cmd` directory
+// because go:embed doesn't support relative path
+//
+//go:embed frontend/static/*
+var webStaticFiles embed.FS
+
 // NewDiscoverCommand build "discover" command
 func NewDiscoverCommand() *cobra.Command {
 	var cfgFile string
@@ -46,6 +57,97 @@ func NewDiscoverCommand() *cobra.Command {
 	return &cmd
 }
 
+// Server represent server
+type Server struct {
+	apiServer         *http.Server
+	promMetricsServer *http.Server
+	logger            *logrus.Logger
+	storage           storage.Storage
+}
+
+// NewServer instantiate new server
+func NewServer(logger *logrus.Logger, storage storage.Storage) *Server {
+	return &Server{
+		logger:  logger,
+		storage: storage,
+	}
+}
+
+func (s *Server) setupAPIServer(port string) {
+	r := chi.NewRouter()
+
+	// Set up CORS
+	crs := cors.New(cors.Options{
+		AllowedOrigins:   []string{"*"}, // Allow all origins
+		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
+		AllowCredentials: true,
+		MaxAge:           300, // Maximum age to cache preflight request
+	})
+	r.Use(crs.Handler)
+
+	// Redirect the home page to /app/index.html
+	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+		http.Redirect(w, r, "/app/index.html", http.StatusMovedPermanently)
+	})
+
+	// Create a new router group
+	r.Route("/api", func(r chi.Router) {
+		r.Route("/v1", func(r chi.Router) {
+			r.Get("/resources", api.GetAllResources(s.storage))
+		})
+	})
+
+	// Serve static files
+	r.Get("/app/*", func(w http.ResponseWriter, r *http.Request) {
+		// Create a subdirectory for the embedded files
+		staticFS, err := fs.Sub(webStaticFiles, "frontend/static")
+		if err != nil {
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+			return
+		}
+
+		// Strip the "/app" prefix and serve the files
+		http.StripPrefix("/app", http.FileServer(http.FS(staticFS))).ServeHTTP(w, r)
+	})
+
+	r.Get("/ping", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("pong"))
+	})
+
+	s.apiServer = &http.Server{
+		Addr:    ":" + port,
+		Handler: r,
+	}
+}
+
+func (s *Server) setupPromMetricsServer() {
+	mux := http.NewServeMux()
+	mux.Handle("/metrics", promhttp.Handler())
+
+	s.promMetricsServer = &http.Server{
+		Addr:    ":2112",
+		Handler: mux,
+	}
+}
+
+func (s *Server) startServer(server *http.Server, serverName string) {
+	go func() {
+		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			s.logger.WithError(err).Errorf("failed to start %s server", serverName)
+		}
+	}()
+}
+
+func (s *Server) shutdownServer(ctx context.Context, server *http.Server, serverName string) error {
+	if err := server.Shutdown(ctx); err != nil {
+		s.logger.WithError(err).Errorf("failed to shutdown %s gracefully", serverName)
+		return err
+	}
+	s.apiServer = nil
+	return nil
+}
+
 func run(ctx context.Context, appConfig *config.AppConfig, logger *logrus.Logger) error {
 	st, err := storage.BuildStorage(appConfig)
 	if err != nil {
@@ -73,35 +175,12 @@ func run(ctx context.Context, appConfig *config.AppConfig, logger *logrus.Logger
 
 	logger.Info("started processing scheduled jobs")
 
-	// Set up your handler
-	http.Handle("/metrics", promhttp.Handler())
-
-	// Use http.Server directly to gain control over its lifecycle
-	promMetricsServer := &http.Server{
-		Addr: ":2112",
-	}
+	s := NewServer(logger, st)
+	s.setupAPIServer("8080")
+	s.setupPromMetricsServer()
 
-	// Start server in a separate goroutine so it doesn't block
-	go func() {
-		if err := promMetricsServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
-			logger.WithError(err).Error("failed to start http server")
-		}
-	}()
-
-	// Start another HTTP server for the API server
-	apiServer := &http.Server{
-		Addr: ":8080",
-	}
-
-	http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
-		w.Write([]byte("pong"))
-	})
-
-	go func() {
-		if err := apiServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
-			logger.WithError(err).Error("failed to start API server")
-		}
-	}()
+	s.startServer(s.promMetricsServer, "metrics")
+	s.startServer(s.apiServer, "api")
 
 	// Wait for context cancellation (in your case, the timeout)
 	<-ctx.Done()
@@ -110,13 +189,11 @@ func run(ctx context.Context, appConfig *config.AppConfig, logger *logrus.Logger
 	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 
-	if err := promMetricsServer.Shutdown(shutdownCtx); err != nil {
-		logger.WithError(err).Error("failed to shutdown Prometheus metrics server gracefully")
+	if err := s.shutdownServer(shutdownCtx, s.apiServer, "API server"); err != nil {
 		return err
 	}
 
-	if err := apiServer.Shutdown(shutdownCtx); err != nil {
-		logger.WithError(err).Error("failed to shutdown API server gracefully")
+	if err := s.shutdownServer(shutdownCtx, s.promMetricsServer, "Prometheus metrics server"); err != nil {
 		return err
 	}
 

cmd/discover_unit_test.go

@@ -0,0 +1,123 @@
+package cmd
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/go-chi/chi"
+	"github.com/shaharia-lab/teredix/pkg/resource"
+	"github.com/shaharia-lab/teredix/pkg/storage"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func TestServer_SetupAPIServer(t *testing.T) {
+	logger := logrus.New()
+	st := new(storage.Mock)
+
+	s := NewServer(logger, st)
+
+	s.setupAPIServer("8080")
+
+	assert.NotNil(t, s.apiServer)
+	assert.Equal(t, ":8080", s.apiServer.Addr)
+}
+
+func TestServer_APIEndpoint(t *testing.T) {
+	logger := logrus.New()
+	st := new(storage.Mock)
+
+	r1 := resource.NewResource("vm", "test", "test", "test", 1)
+	st.On("Find", mock.Anything).Return([]resource.Resource{r1}, nil)
+
+	s := NewServer(logger, st)
+	s.setupAPIServer("8080")
+
+	r := chi.NewRouter()
+	r.Mount("/", s.apiServer.Handler)
+
+	ts := httptest.NewServer(r)
+	defer ts.Close()
+
+	res, err := http.Get(ts.URL + "/api/v1/resources?page=1&per_page=10")
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, res.StatusCode)
+
+	res, err = http.Get(ts.URL + "/api/v1/resources?page=1&per_page=300")
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, res.StatusCode)
+
+	res, err = http.Get(ts.URL + "/api/v1/resources")
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, res.StatusCode)
+}
+
+func TestServer_SetupPromMetricsServer(t *testing.T) {
+	logger := logrus.New()
+	s := NewServer(logger, nil)
+
+	s.setupPromMetricsServer()
+
+	assert.NotNil(t, s.promMetricsServer)
+	assert.Equal(t, ":2112", s.promMetricsServer.Addr)
+}
+
+func TestServer_PromMetricsEndpoint(t *testing.T) {
+	logger := logrus.New()
+	s := NewServer(logger, nil)
+	s.setupPromMetricsServer()
+
+	ts := httptest.NewServer(s.promMetricsServer.Handler)
+	defer ts.Close()
+
+	res, err := http.Get(ts.URL + "/metrics")
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, res.StatusCode)
+}
+
+func TestServer_StartAndShutdownServer(t *testing.T) {
+	// Arrange
+	logger := logrus.New()
+	s := NewServer(logger, nil)
+	s.setupAPIServer("0")
+
+	// Act
+	// Start the server in a separate goroutine so it doesn't block
+	go s.startServer(s.apiServer, "API server")
+
+	// Create a context with a timeout
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	// Wait for the server to start
+	time.Sleep(100 * time.Millisecond)
+
+	// Send a request to the server
+	ts := httptest.NewServer(s.apiServer.Handler)
+	defer ts.Close()
+
+	resp, err := http.Get(ts.URL + "/ping")
+
+	// Assert
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	// Act
+	// Shutdown the server
+	err = s.shutdownServer(ctx, s.apiServer, "API server")
+
+	// Assert
+	assert.NoError(t, err)
+
+	// Wait for the server to shutdown
+	time.Sleep(100 * time.Millisecond)
+
+	// Check if the server is still running
+	if s.apiServer != nil {
+		t.Errorf("Server is still running after shutdown")
+	}
+}