feat(server/v2): Add Swagger UI support for server/v2

server/v2/api/swagger/config.go

@@ -0,0 +1,36 @@
+package swagger
+
+import (
+    "fmt"
+
+    "cosmossdk.io/core/server"
+)
+
+const ServerName = "swagger"
+
+// Config defines the configuration for the Swagger UI server
+type Config struct {
+    Enable  bool   `toml:"enable" mapstructure:"enable"`
+    Address string `toml:"address" mapstructure:"address"`
+    Path    string `toml:"path" mapstructure:"path"`
+}
+
+// DefaultConfig returns the default configuration
+func DefaultConfig() *Config {
+    return &Config{
+        Enable:  true,
+        Address: "localhost:8080",
+        Path:    "/swagger/",
+    }
+}
+
+// Validate checks the configuration
+func (c Config) Validate() error {
+    if c.Path == "" {
+        return fmt.Errorf("swagger path cannot be empty")
+    }
+    return nil
+}
+
+// CfgOption defines a function for configuring the settings
+type CfgOption func(*Config)

server/v2/api/swagger/handler.go

@@ -0,0 +1,85 @@
+package swagger
+
+import (
+    "io"
+    "net/http"
+    "path/filepath"
+    "strings"
+    "time"
+
+    "github.com/rakyll/statik/fs"
+)
+
+// Handler returns an HTTP handler for Swagger UI
+func Handler() http.Handler {
+    return &swaggerHandler{}
+}
+
+type swaggerHandler struct{}
+
+func (h *swaggerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+    // Set CORS headers
+    w.Header().Set("Access-Control-Allow-Origin", "*")
+    w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+    w.Header().Set("Access-Control-Allow-Headers", "DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type")
+
+    if r.Method == http.MethodOptions {
+        return
+    }
+
+    // Get the static file system
+    statikFS, err := fs.New()
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }
+
+    // Process the path
+    urlPath := strings.TrimPrefix(r.URL.Path, "/swagger")
+    if urlPath == "" || urlPath == "/" {
+        urlPath = "/index.html"
+    }
+
+    // Open the file
+    file, err := statikFS.Open(urlPath)
+    if err != nil {
+        http.Error(w, "File not found", http.StatusNotFound)
+        return
+    }
+    defer file.Close()
+
+    // Set the content-type
+    ext := filepath.Ext(urlPath)
+    if ct := getContentType(ext); ct != "" {
+        w.Header().Set("Content-Type", ct)
+    }
+
+    // Set caching headers
+    w.Header().Set("Cache-Control", "public, max-age=31536000")
+    w.Header().Set("Last-Modified", time.Now().UTC().Format(http.TimeFormat))
+
+    // Serve the file
+    http.ServeContent(w, r, urlPath, time.Now(), file.(io.ReadSeeker))
+}
+
+// getContentType returns the content-type for a file extension
+func getContentType(ext string) string {
+    switch strings.ToLower(ext) {
+    case ".html":
+        return "text/html"
+    case ".css":
+        return "text/css"
+    case ".js":
+        return "application/javascript"
+    case ".json":
+        return "application/json"
+    case ".png":
+        return "image/png"
+    case ".jpg", ".jpeg":
+        return "image/jpeg"
+    case ".svg":
+        return "image/svg+xml"
+    default:
+        return ""
+    }
+}

server/v2/api/swagger/server.go

@@ -0,0 +1,108 @@
+package swagger
+
+import (
+    "context"
+    "fmt"
+    "net/http"
+
+    "cosmossdk.io/core/server"
+    "cosmossdk.io/core/transaction"
+    "cosmossdk.io/log"
+    serverv2 "cosmossdk.io/server/v2"
+)
+
+var (
+    _ serverv2.ServerComponent[transaction.Tx] = (*Server[transaction.Tx])(nil)
+    _ serverv2.HasConfig                       = (*Server[transaction.Tx])(nil)
+)
+
+// Server represents a Swagger UI server
+type Server[T transaction.Tx] struct {
+    logger     log.Logger
+    config     *Config
+    cfgOptions []CfgOption
+    server     *http.Server
+}
+
+// New creates a new Swagger UI server
+func New[T transaction.Tx](
+    logger log.Logger,
+    cfg server.ConfigMap,
+    cfgOptions ...CfgOption,
+) (*Server[T], error) {
+    srv := &Server[T]{
+        logger:     logger.With(log.ModuleKey, ServerName),
+        cfgOptions: cfgOptions,
+    }
+
+    serverCfg := srv.Config().(*Config)
+    if len(cfg) > 0 {
+        if err := serverv2.UnmarshalSubConfig(cfg, srv.Name(), &serverCfg); err != nil {
+            return nil, fmt.Errorf("failed to unmarshal config: %w", err)
+        }
+    }
+    srv.config = serverCfg
+
+    if err := srv.config.Validate(); err != nil {
+        return nil, err
+    }
+
+    mux := http.NewServeMux()
+    mux.Handle(srv.config.Path, Handler())
+
+    srv.server = &http.Server{
+        Addr:    srv.config.Address,
+        Handler: mux,
+    }
+
+    return srv, nil
+}
+
+// NewWithConfigOptions creates a new server with configuration options
+func NewWithConfigOptions[T transaction.Tx](opts ...CfgOption) *Server[T] {
+    return &Server[T]{
+        cfgOptions: opts,
+    }
+}
+
+// Name returns the server's name
+func (s *Server[T]) Name() string {
+    return ServerName
+}
+
+// Config returns the server configuration
+func (s *Server[T]) Config() any {
+    if s.config == nil || s.config.Address == "" {
+        cfg := DefaultConfig()
+        for _, opt := range s.cfgOptions {
+            opt(cfg)
+        }
+        return cfg
+    }
+    return s.config
+}
+
+// Start starts the server
+func (s *Server[T]) Start(ctx context.Context) error {
+    if !s.config.Enable {
+        s.logger.Info(fmt.Sprintf("%s server is disabled via config", s.Name()))
+        return nil
+    }
+
+    s.logger.Info("starting swagger server...", "address", s.config.Address)
+    if err := s.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+        return fmt.Errorf("failed to start swagger server: %w", err)
+    }
+
+    return nil
+}
+
+// Stop stops the server
+func (s *Server[T]) Stop(ctx context.Context) error {
+    if !s.config.Enable {
+        return nil
+    }
+
+    s.logger.Info("stopping swagger server...", "address", s.config.Address)
+    return s.server.Shutdown(ctx)
+}