794 lines
25 KiB
Go
794 lines
25 KiB
Go
package scst
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/atlasos/calypso/internal/common/database"
|
|
"github.com/atlasos/calypso/internal/common/logger"
|
|
"github.com/atlasos/calypso/internal/tasks"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/go-playground/validator/v10"
|
|
)
|
|
|
|
// Handler handles SCST-related API requests
|
|
type Handler struct {
|
|
service *Service
|
|
taskEngine *tasks.Engine
|
|
db *database.DB
|
|
logger *logger.Logger
|
|
}
|
|
|
|
// NewHandler creates a new SCST handler
|
|
func NewHandler(db *database.DB, log *logger.Logger) *Handler {
|
|
return &Handler{
|
|
service: NewService(db, log),
|
|
taskEngine: tasks.NewEngine(db, log),
|
|
db: db,
|
|
logger: log,
|
|
}
|
|
}
|
|
|
|
// ListTargets lists all SCST targets
|
|
func (h *Handler) ListTargets(c *gin.Context) {
|
|
targets, err := h.service.ListTargets(c.Request.Context())
|
|
if err != nil {
|
|
h.logger.Error("Failed to list targets", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list targets"})
|
|
return
|
|
}
|
|
|
|
// Ensure we return an empty array instead of null
|
|
if targets == nil {
|
|
targets = []Target{}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"targets": targets})
|
|
}
|
|
|
|
// GetTarget retrieves a target by ID
|
|
func (h *Handler) GetTarget(c *gin.Context) {
|
|
targetID := c.Param("id")
|
|
|
|
target, err := h.service.GetTarget(c.Request.Context(), targetID)
|
|
if err != nil {
|
|
if err.Error() == "target not found" {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "target not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to get target", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get target"})
|
|
return
|
|
}
|
|
|
|
// Get LUNs
|
|
luns, err := h.service.GetTargetLUNs(c.Request.Context(), targetID)
|
|
if err != nil {
|
|
h.logger.Warn("Failed to get LUNs", "target_id", targetID, "error", err)
|
|
// Return empty array instead of nil
|
|
luns = []LUN{}
|
|
}
|
|
|
|
// Get initiator groups
|
|
groups, err2 := h.service.GetTargetInitiatorGroups(c.Request.Context(), targetID)
|
|
if err2 != nil {
|
|
h.logger.Warn("Failed to get initiator groups", "target_id", targetID, "error", err2)
|
|
groups = []InitiatorGroup{}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"target": target,
|
|
"luns": luns,
|
|
"initiator_groups": groups,
|
|
})
|
|
}
|
|
|
|
// CreateTargetRequest represents a target creation request
|
|
type CreateTargetRequest struct {
|
|
IQN string `json:"iqn" binding:"required"`
|
|
TargetType string `json:"target_type" binding:"required"`
|
|
Name string `json:"name" binding:"required"`
|
|
Description string `json:"description"`
|
|
SingleInitiatorOnly bool `json:"single_initiator_only"`
|
|
}
|
|
|
|
// CreateTarget creates a new SCST target
|
|
func (h *Handler) CreateTarget(c *gin.Context) {
|
|
var req CreateTargetRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
|
|
return
|
|
}
|
|
|
|
userID, _ := c.Get("user_id")
|
|
|
|
target := &Target{
|
|
IQN: req.IQN,
|
|
TargetType: req.TargetType,
|
|
Name: req.Name,
|
|
Description: req.Description,
|
|
IsActive: true,
|
|
SingleInitiatorOnly: req.SingleInitiatorOnly || req.TargetType == "vtl" || req.TargetType == "physical_tape",
|
|
CreatedBy: userID.(string),
|
|
}
|
|
|
|
if err := h.service.CreateTarget(c.Request.Context(), target); err != nil {
|
|
h.logger.Error("Failed to create target", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Set alias to name for frontend compatibility (same as ListTargets)
|
|
target.Alias = target.Name
|
|
// LUNCount will be 0 for newly created target
|
|
target.LUNCount = 0
|
|
|
|
c.JSON(http.StatusCreated, target)
|
|
}
|
|
|
|
// AddLUNRequest represents a LUN addition request
|
|
type AddLUNRequest struct {
|
|
DeviceName string `json:"device_name" binding:"required"`
|
|
DevicePath string `json:"device_path" binding:"required"`
|
|
LUNNumber int `json:"lun_number"` // Note: cannot use binding:"required" for int as 0 is valid
|
|
HandlerType string `json:"handler_type" binding:"required"`
|
|
}
|
|
|
|
// AddLUN adds a LUN to a target
|
|
func (h *Handler) AddLUN(c *gin.Context) {
|
|
targetID := c.Param("id")
|
|
|
|
target, err := h.service.GetTarget(c.Request.Context(), targetID)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "target not found"})
|
|
return
|
|
}
|
|
|
|
var req AddLUNRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
h.logger.Error("Failed to bind AddLUN request", "error", err)
|
|
// Provide more detailed error message
|
|
if validationErr, ok := err.(validator.ValidationErrors); ok {
|
|
var errorMessages []string
|
|
for _, fieldErr := range validationErr {
|
|
errorMessages = append(errorMessages, fmt.Sprintf("%s is required", fieldErr.Field()))
|
|
}
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("validation failed: %s", strings.Join(errorMessages, ", "))})
|
|
} else {
|
|
// Extract error message without full struct name
|
|
errMsg := err.Error()
|
|
if idx := strings.Index(errMsg, "Key: '"); idx >= 0 {
|
|
// Extract field name from error message
|
|
fieldStart := idx + 6 // Length of "Key: '"
|
|
if fieldEnd := strings.Index(errMsg[fieldStart:], "'"); fieldEnd >= 0 {
|
|
fieldName := errMsg[fieldStart : fieldStart+fieldEnd]
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("invalid or missing field: %s", fieldName)})
|
|
} else {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request format"})
|
|
}
|
|
} else {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("invalid request: %v", err)})
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Validate required fields (additional check in case binding doesn't catch it)
|
|
if req.DeviceName == "" || req.DevicePath == "" || req.HandlerType == "" {
|
|
h.logger.Error("Missing required fields in AddLUN request", "device_name", req.DeviceName, "device_path", req.DevicePath, "handler_type", req.HandlerType)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "device_name, device_path, and handler_type are required"})
|
|
return
|
|
}
|
|
|
|
// Validate LUN number range
|
|
if req.LUNNumber < 0 || req.LUNNumber > 255 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "lun_number must be between 0 and 255"})
|
|
return
|
|
}
|
|
|
|
if err := h.service.AddLUN(c.Request.Context(), target.IQN, req.DeviceName, req.DevicePath, req.LUNNumber, req.HandlerType); err != nil {
|
|
h.logger.Error("Failed to add LUN", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "LUN added successfully"})
|
|
}
|
|
|
|
// RemoveLUN removes a LUN from a target
|
|
func (h *Handler) RemoveLUN(c *gin.Context) {
|
|
targetID := c.Param("id")
|
|
lunID := c.Param("lunId")
|
|
|
|
// Get target
|
|
target, err := h.service.GetTarget(c.Request.Context(), targetID)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "target not found"})
|
|
return
|
|
}
|
|
|
|
// Get LUN to get the LUN number
|
|
var lunNumber int
|
|
err = h.db.QueryRowContext(c.Request.Context(),
|
|
"SELECT lun_number FROM scst_luns WHERE id = $1 AND target_id = $2",
|
|
lunID, targetID,
|
|
).Scan(&lunNumber)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "no rows") {
|
|
// LUN already deleted from database - check if it still exists in SCST
|
|
// Try to get LUN number from URL or try common LUN numbers
|
|
// For now, return success since it's already deleted (idempotent)
|
|
h.logger.Info("LUN not found in database, may already be deleted", "lun_id", lunID, "target_id", targetID)
|
|
c.JSON(http.StatusOK, gin.H{"message": "LUN already removed or not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to get LUN", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get LUN"})
|
|
return
|
|
}
|
|
|
|
// Remove LUN
|
|
if err := h.service.RemoveLUN(c.Request.Context(), target.IQN, lunNumber); err != nil {
|
|
h.logger.Error("Failed to remove LUN", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "LUN removed successfully"})
|
|
}
|
|
|
|
// AddInitiatorRequest represents an initiator addition request
|
|
type AddInitiatorRequest struct {
|
|
InitiatorIQN string `json:"initiator_iqn" binding:"required"`
|
|
}
|
|
|
|
// AddInitiator adds an initiator to a target
|
|
func (h *Handler) AddInitiator(c *gin.Context) {
|
|
targetID := c.Param("id")
|
|
|
|
target, err := h.service.GetTarget(c.Request.Context(), targetID)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "target not found"})
|
|
return
|
|
}
|
|
|
|
var req AddInitiatorRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
|
|
return
|
|
}
|
|
|
|
if err := h.service.AddInitiator(c.Request.Context(), target.IQN, req.InitiatorIQN); err != nil {
|
|
h.logger.Error("Failed to add initiator", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Initiator added successfully"})
|
|
}
|
|
|
|
// AddInitiatorToGroupRequest represents a request to add an initiator to a group
|
|
type AddInitiatorToGroupRequest struct {
|
|
InitiatorIQN string `json:"initiator_iqn" binding:"required"`
|
|
}
|
|
|
|
// AddInitiatorToGroup adds an initiator to a specific group
|
|
func (h *Handler) AddInitiatorToGroup(c *gin.Context) {
|
|
groupID := c.Param("id")
|
|
|
|
var req AddInitiatorToGroupRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
validationErrors := make(map[string]string)
|
|
if ve, ok := err.(validator.ValidationErrors); ok {
|
|
for _, fe := range ve {
|
|
field := strings.ToLower(fe.Field())
|
|
validationErrors[field] = fmt.Sprintf("Field '%s' is required", field)
|
|
}
|
|
}
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "invalid request",
|
|
"validation_errors": validationErrors,
|
|
})
|
|
return
|
|
}
|
|
|
|
err := h.service.AddInitiatorToGroup(c.Request.Context(), groupID, req.InitiatorIQN)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "not found") || strings.Contains(err.Error(), "already exists") || strings.Contains(err.Error(), "single initiator only") {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to add initiator to group", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to add initiator to group"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Initiator added to group successfully"})
|
|
}
|
|
|
|
// ListAllInitiators lists all initiators across all targets
|
|
func (h *Handler) ListAllInitiators(c *gin.Context) {
|
|
initiators, err := h.service.ListAllInitiators(c.Request.Context())
|
|
if err != nil {
|
|
h.logger.Error("Failed to list initiators", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list initiators"})
|
|
return
|
|
}
|
|
|
|
if initiators == nil {
|
|
initiators = []InitiatorWithTarget{}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"initiators": initiators})
|
|
}
|
|
|
|
// RemoveInitiator removes an initiator
|
|
func (h *Handler) RemoveInitiator(c *gin.Context) {
|
|
initiatorID := c.Param("id")
|
|
|
|
if err := h.service.RemoveInitiator(c.Request.Context(), initiatorID); err != nil {
|
|
if err.Error() == "initiator not found" {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "initiator not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to remove initiator", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Initiator removed successfully"})
|
|
}
|
|
|
|
// GetInitiator retrieves an initiator by ID
|
|
func (h *Handler) GetInitiator(c *gin.Context) {
|
|
initiatorID := c.Param("id")
|
|
|
|
initiator, err := h.service.GetInitiator(c.Request.Context(), initiatorID)
|
|
if err != nil {
|
|
if err.Error() == "initiator not found" {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "initiator not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to get initiator", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get initiator"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, initiator)
|
|
}
|
|
|
|
// ListExtents lists all device extents
|
|
func (h *Handler) ListExtents(c *gin.Context) {
|
|
extents, err := h.service.ListExtents(c.Request.Context())
|
|
if err != nil {
|
|
h.logger.Error("Failed to list extents", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list extents"})
|
|
return
|
|
}
|
|
|
|
if extents == nil {
|
|
extents = []Extent{}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"extents": extents})
|
|
}
|
|
|
|
// CreateExtentRequest represents a request to create an extent
|
|
type CreateExtentRequest struct {
|
|
DeviceName string `json:"device_name" binding:"required"`
|
|
DevicePath string `json:"device_path" binding:"required"`
|
|
HandlerType string `json:"handler_type" binding:"required"`
|
|
}
|
|
|
|
// CreateExtent creates a new device extent
|
|
func (h *Handler) CreateExtent(c *gin.Context) {
|
|
var req CreateExtentRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
|
|
return
|
|
}
|
|
|
|
if err := h.service.CreateExtent(c.Request.Context(), req.DeviceName, req.DevicePath, req.HandlerType); err != nil {
|
|
h.logger.Error("Failed to create extent", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusCreated, gin.H{"message": "Extent created successfully"})
|
|
}
|
|
|
|
// DeleteExtent deletes a device extent
|
|
func (h *Handler) DeleteExtent(c *gin.Context) {
|
|
deviceName := c.Param("device")
|
|
|
|
if err := h.service.DeleteExtent(c.Request.Context(), deviceName); err != nil {
|
|
h.logger.Error("Failed to delete extent", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Extent deleted successfully"})
|
|
}
|
|
|
|
// ApplyConfig applies SCST configuration
|
|
func (h *Handler) ApplyConfig(c *gin.Context) {
|
|
userID, _ := c.Get("user_id")
|
|
|
|
// Create async task
|
|
taskID, err := h.taskEngine.CreateTask(c.Request.Context(),
|
|
tasks.TaskTypeApplySCST, userID.(string), map[string]interface{}{
|
|
"operation": "apply_scst_config",
|
|
})
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create task"})
|
|
return
|
|
}
|
|
|
|
// Run apply in background
|
|
go func() {
|
|
ctx := c.Request.Context()
|
|
h.taskEngine.StartTask(ctx, taskID)
|
|
h.taskEngine.UpdateProgress(ctx, taskID, 50, "Writing SCST configuration...")
|
|
|
|
configPath := "/etc/calypso/scst/generated.conf"
|
|
if err := h.service.WriteConfig(ctx, configPath); err != nil {
|
|
h.taskEngine.FailTask(ctx, taskID, err.Error())
|
|
return
|
|
}
|
|
|
|
h.taskEngine.UpdateProgress(ctx, taskID, 100, "SCST configuration applied")
|
|
h.taskEngine.CompleteTask(ctx, taskID, "SCST configuration applied successfully")
|
|
}()
|
|
|
|
c.JSON(http.StatusAccepted, gin.H{"task_id": taskID})
|
|
}
|
|
|
|
// ListHandlers lists available SCST handlers
|
|
func (h *Handler) ListHandlers(c *gin.Context) {
|
|
handlers, err := h.service.DetectHandlers(c.Request.Context())
|
|
if err != nil {
|
|
h.logger.Error("Failed to list handlers", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list handlers"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"handlers": handlers})
|
|
}
|
|
|
|
// ListPortals lists all iSCSI portals
|
|
func (h *Handler) ListPortals(c *gin.Context) {
|
|
portals, err := h.service.ListPortals(c.Request.Context())
|
|
if err != nil {
|
|
h.logger.Error("Failed to list portals", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list portals"})
|
|
return
|
|
}
|
|
|
|
// Ensure we return an empty array instead of null
|
|
if portals == nil {
|
|
portals = []Portal{}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"portals": portals})
|
|
}
|
|
|
|
// CreatePortal creates a new portal
|
|
func (h *Handler) CreatePortal(c *gin.Context) {
|
|
var portal Portal
|
|
if err := c.ShouldBindJSON(&portal); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
|
|
return
|
|
}
|
|
|
|
if err := h.service.CreatePortal(c.Request.Context(), &portal); err != nil {
|
|
h.logger.Error("Failed to create portal", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusCreated, portal)
|
|
}
|
|
|
|
// UpdatePortal updates a portal
|
|
func (h *Handler) UpdatePortal(c *gin.Context) {
|
|
id := c.Param("id")
|
|
|
|
var portal Portal
|
|
if err := c.ShouldBindJSON(&portal); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
|
|
return
|
|
}
|
|
|
|
if err := h.service.UpdatePortal(c.Request.Context(), id, &portal); err != nil {
|
|
if err.Error() == "portal not found" {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "portal not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to update portal", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, portal)
|
|
}
|
|
|
|
// EnableTarget enables a target
|
|
func (h *Handler) EnableTarget(c *gin.Context) {
|
|
targetID := c.Param("id")
|
|
|
|
target, err := h.service.GetTarget(c.Request.Context(), targetID)
|
|
if err != nil {
|
|
if err.Error() == "target not found" {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "target not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to get target", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get target"})
|
|
return
|
|
}
|
|
|
|
if err := h.service.EnableTarget(c.Request.Context(), target.IQN); err != nil {
|
|
h.logger.Error("Failed to enable target", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Target enabled successfully"})
|
|
}
|
|
|
|
// DisableTarget disables a target
|
|
func (h *Handler) DisableTarget(c *gin.Context) {
|
|
targetID := c.Param("id")
|
|
|
|
target, err := h.service.GetTarget(c.Request.Context(), targetID)
|
|
if err != nil {
|
|
if err.Error() == "target not found" {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "target not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to get target", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get target"})
|
|
return
|
|
}
|
|
|
|
if err := h.service.DisableTarget(c.Request.Context(), target.IQN); err != nil {
|
|
h.logger.Error("Failed to disable target", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Target disabled successfully"})
|
|
}
|
|
|
|
// DeleteTarget deletes a target
|
|
func (h *Handler) DeleteTarget(c *gin.Context) {
|
|
targetID := c.Param("id")
|
|
|
|
if err := h.service.DeleteTarget(c.Request.Context(), targetID); err != nil {
|
|
if err.Error() == "target not found" {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "target not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to delete target", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Target deleted successfully"})
|
|
}
|
|
|
|
// DeletePortal deletes a portal
|
|
func (h *Handler) DeletePortal(c *gin.Context) {
|
|
id := c.Param("id")
|
|
|
|
if err := h.service.DeletePortal(c.Request.Context(), id); err != nil {
|
|
if err.Error() == "portal not found" {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "portal not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to delete portal", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Portal deleted successfully"})
|
|
}
|
|
|
|
// GetPortal retrieves a portal by ID
|
|
func (h *Handler) GetPortal(c *gin.Context) {
|
|
id := c.Param("id")
|
|
|
|
portal, err := h.service.GetPortal(c.Request.Context(), id)
|
|
if err != nil {
|
|
if err.Error() == "portal not found" {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "portal not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to get portal", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get portal"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, portal)
|
|
}
|
|
|
|
// CreateInitiatorGroupRequest represents a request to create an initiator group
|
|
type CreateInitiatorGroupRequest struct {
|
|
TargetID string `json:"target_id" binding:"required"`
|
|
GroupName string `json:"group_name" binding:"required"`
|
|
}
|
|
|
|
// CreateInitiatorGroup creates a new initiator group
|
|
func (h *Handler) CreateInitiatorGroup(c *gin.Context) {
|
|
var req CreateInitiatorGroupRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
validationErrors := make(map[string]string)
|
|
if ve, ok := err.(validator.ValidationErrors); ok {
|
|
for _, fe := range ve {
|
|
field := strings.ToLower(fe.Field())
|
|
validationErrors[field] = fmt.Sprintf("Field '%s' is required", field)
|
|
}
|
|
}
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "invalid request",
|
|
"validation_errors": validationErrors,
|
|
})
|
|
return
|
|
}
|
|
|
|
group, err := h.service.CreateInitiatorGroup(c.Request.Context(), req.TargetID, req.GroupName)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "already exists") || strings.Contains(err.Error(), "not found") {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to create initiator group", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create initiator group"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, group)
|
|
}
|
|
|
|
// UpdateInitiatorGroupRequest represents a request to update an initiator group
|
|
type UpdateInitiatorGroupRequest struct {
|
|
GroupName string `json:"group_name" binding:"required"`
|
|
}
|
|
|
|
// UpdateInitiatorGroup updates an initiator group
|
|
func (h *Handler) UpdateInitiatorGroup(c *gin.Context) {
|
|
groupID := c.Param("id")
|
|
|
|
var req UpdateInitiatorGroupRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
validationErrors := make(map[string]string)
|
|
if ve, ok := err.(validator.ValidationErrors); ok {
|
|
for _, fe := range ve {
|
|
field := strings.ToLower(fe.Field())
|
|
validationErrors[field] = fmt.Sprintf("Field '%s' is required", field)
|
|
}
|
|
}
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "invalid request",
|
|
"validation_errors": validationErrors,
|
|
})
|
|
return
|
|
}
|
|
|
|
group, err := h.service.UpdateInitiatorGroup(c.Request.Context(), groupID, req.GroupName)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "not found") || strings.Contains(err.Error(), "already exists") {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to update initiator group", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to update initiator group"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, group)
|
|
}
|
|
|
|
// DeleteInitiatorGroup deletes an initiator group
|
|
func (h *Handler) DeleteInitiatorGroup(c *gin.Context) {
|
|
groupID := c.Param("id")
|
|
|
|
err := h.service.DeleteInitiatorGroup(c.Request.Context(), groupID)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "not found") {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
if strings.Contains(err.Error(), "cannot delete") || strings.Contains(err.Error(), "contains") {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to delete initiator group", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete initiator group"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "initiator group deleted successfully"})
|
|
}
|
|
|
|
// GetInitiatorGroup retrieves an initiator group by ID
|
|
func (h *Handler) GetInitiatorGroup(c *gin.Context) {
|
|
groupID := c.Param("id")
|
|
|
|
group, err := h.service.GetInitiatorGroup(c.Request.Context(), groupID)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "not found") {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "initiator group not found"})
|
|
return
|
|
}
|
|
h.logger.Error("Failed to get initiator group", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get initiator group"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, group)
|
|
}
|
|
|
|
// ListAllInitiatorGroups lists all initiator groups
|
|
func (h *Handler) ListAllInitiatorGroups(c *gin.Context) {
|
|
groups, err := h.service.ListAllInitiatorGroups(c.Request.Context())
|
|
if err != nil {
|
|
h.logger.Error("Failed to list initiator groups", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list initiator groups"})
|
|
return
|
|
}
|
|
|
|
if groups == nil {
|
|
groups = []InitiatorGroup{}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{"groups": groups})
|
|
}
|
|
|
|
// GetConfigFile reads the SCST configuration file content
|
|
func (h *Handler) GetConfigFile(c *gin.Context) {
|
|
configPath := c.DefaultQuery("path", "/etc/scst.conf")
|
|
|
|
content, err := h.service.ReadConfigFile(c.Request.Context(), configPath)
|
|
if err != nil {
|
|
h.logger.Error("Failed to read config file", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"content": content,
|
|
"path": configPath,
|
|
})
|
|
}
|
|
|
|
// UpdateConfigFile writes content to SCST configuration file
|
|
func (h *Handler) UpdateConfigFile(c *gin.Context) {
|
|
var req struct {
|
|
Content string `json:"content" binding:"required"`
|
|
Path string `json:"path"`
|
|
}
|
|
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
|
|
return
|
|
}
|
|
|
|
configPath := req.Path
|
|
if configPath == "" {
|
|
configPath = "/etc/scst.conf"
|
|
}
|
|
|
|
if err := h.service.WriteConfigFile(c.Request.Context(), configPath, req.Content); err != nil {
|
|
h.logger.Error("Failed to write config file", "error", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"message": "Configuration file updated successfully",
|
|
"path": configPath,
|
|
})
|
|
}
|