197 lines
6.0 KiB
Plaintext
197 lines
6.0 KiB
Plaintext
package api
|
|
|
|
//import (
|
|
// "context"
|
|
// "daemonService/internal/models"
|
|
// "encoding/json"
|
|
// "fmt"
|
|
// "io"
|
|
// "log"
|
|
// "net/http"
|
|
// "time"
|
|
//
|
|
// "daemonService/internal/services"
|
|
//
|
|
// "github.com/gorilla/mux"
|
|
//)
|
|
//
|
|
//// APIResponse estructura la respuesta común del API.
|
|
//type APIResponse struct {
|
|
// Success bool `json:"success"`
|
|
// Message string `json:"message"`
|
|
// Data interface{} `json:"data,omitempty"`
|
|
// Error string `json:"error,omitempty"`
|
|
//}
|
|
//
|
|
//// setupAPIHandlers configura los endpoints del API HTTP.
|
|
//func setupAPIHandlers(router *mux.Router, service []models.SoapService, isCron bool) {
|
|
// // Lista de servicios disponibles
|
|
// router.HandleFunc("/api/services", func(w http.ResponseWriter, r *http.Request) {
|
|
// serviceNames := make([]string, len(service))
|
|
// for i, svc := range service {
|
|
// serviceNames[i] = svc.GetName()
|
|
// }
|
|
//
|
|
// response := APIResponse{
|
|
// Success: true,
|
|
// Message: "Lista de servicios disponibles",
|
|
// Data: serviceNames,
|
|
// }
|
|
// w.Header().Set("Content-Type", "application/json")
|
|
// json.NewEncoder(w).Encode(response)
|
|
// }).Methods("GET")
|
|
//
|
|
// // Ejecutar todos los servicios
|
|
// router.HandleFunc("/api/services/run-all", func(w http.ResponseWriter, r *http.Request) {
|
|
// ctx, cancel := context.WithTimeout(r.Context(), 5*time.Minute)
|
|
// defer cancel()
|
|
//
|
|
// go func() {
|
|
// errors := services.RunAllServices(ctx, service, isCron) //ariel agrego:request
|
|
// log.Printf("Ejecución de todos los servicios completada con %d errores", len(errors))
|
|
// }()
|
|
//
|
|
// response := APIResponse{
|
|
// Success: true,
|
|
// Message: "Ejecución de todos los servicios iniciada",
|
|
// }
|
|
// w.Header().Set("Content-Type", "application/json")
|
|
// json.NewEncoder(w).Encode(response)
|
|
// }).Methods("POST")
|
|
//
|
|
// // Ejecutar un servicio específico
|
|
// router.HandleFunc("/api/services/{name}", func(w http.ResponseWriter, r *http.Request) {
|
|
// vars := mux.Vars(r)
|
|
//
|
|
// //////////////////////////////////////////////////////////////////////////////////////////////
|
|
// // Es importante cerrar el body después de leerlo para liberar recursos.
|
|
// defer r.Body.Close()
|
|
// // Leemos el contenido del body.
|
|
// body, err := io.ReadAll(r.Body)
|
|
// if err != nil {
|
|
// http.Error(w, "Error leyendo el body", http.StatusInternalServerError)
|
|
// return
|
|
// }
|
|
// // Si quieres convertirlo a string:
|
|
// bodyStr := string(body)
|
|
// fmt.Println("Body de la petición:", bodyStr)
|
|
// //////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// serviceName := vars["name"]
|
|
//
|
|
// ctx, cancel := context.WithTimeout(r.Context(), 5*time.Minute)
|
|
// defer cancel()
|
|
//
|
|
// var encontrado bool
|
|
// for _, svc := range service {
|
|
// if svc.GetName() == serviceName {
|
|
// encontrado = true
|
|
// go func() {
|
|
// // if err := svc.Execute(ctx); err != nil {
|
|
// // log.Printf("Error al ejecutar servicio %s: %v", serviceName, err)
|
|
// // } else {
|
|
// // log.Printf("Servicio %s ejecutado correctamente", serviceName)
|
|
// // }
|
|
// if err := svc.Execute(ctx, r, isCron); err != nil { //ariel agrego:request
|
|
// log.Printf("Error al ejecutar servicio %s: %v", serviceName, err) ///modificado
|
|
// } else {
|
|
// log.Printf("Servicio %s ejecutado correctamente", serviceName)
|
|
// }
|
|
// }()
|
|
// break
|
|
// }
|
|
// }
|
|
//
|
|
// if !encontrado {
|
|
// w.WriteHeader(http.StatusNotFound)
|
|
// response := APIResponse{
|
|
// Success: false,
|
|
// Error: fmt.Sprintf("Servicio no encontrado: %s", serviceName),
|
|
// }
|
|
// w.Header().Set("Content-Type", "application/json")
|
|
// json.NewEncoder(w).Encode(response)
|
|
// return
|
|
// }
|
|
//
|
|
// response := APIResponse{
|
|
// Success: true,
|
|
// Message: fmt.Sprintf("Ejecución del servicio %s iniciada", serviceName),
|
|
// }
|
|
// w.Header().Set("Content-Type", "application/json")
|
|
// json.NewEncoder(w).Encode(response)
|
|
// }).Methods("POST")
|
|
//
|
|
// // Health check
|
|
// router.HandleFunc("/api/health", func(w http.ResponseWriter, r *http.Request) {
|
|
// response := APIResponse{
|
|
// Success: true,
|
|
// Message: "Servicio activo",
|
|
// Data: map[string]interface{}{
|
|
// "status": "healthy",
|
|
// "timestamp": time.Now().Format(time.RFC3339),
|
|
// },
|
|
// }
|
|
// w.Header().Set("Content-Type", "application/json")
|
|
// json.NewEncoder(w).Encode(response)
|
|
// }).Methods("GET")
|
|
//}
|
|
//
|
|
//// StartAPIServer inicia el servidor HTTP con la configuración del API.
|
|
//func StartAPIServer(port int, services []models.SoapService, isCron bool) *http.Server {
|
|
// router := mux.NewRouter()
|
|
// setupAPIHandlers(router, services, isCron)
|
|
//
|
|
// // Middleware para logging
|
|
// router.Use(func(next http.Handler) http.Handler {
|
|
// return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
// start := time.Now()
|
|
// log.Printf("API Request: %s %s", r.Method, r.URL.Path)
|
|
// next.ServeHTTP(w, r)
|
|
// log.Printf("API Request: %s %s completada en %v", r.Method, r.URL.Path, time.Since(start))
|
|
// })
|
|
// })
|
|
//
|
|
// srv := &http.Server{
|
|
// Addr: fmt.Sprintf(":%d", port),
|
|
// Handler: router,
|
|
// ReadTimeout: 15 * time.Second,
|
|
// WriteTimeout: 15 * time.Second,
|
|
// IdleTimeout: 60 * time.Second,
|
|
// }
|
|
//
|
|
// go func() {
|
|
// log.Printf("API HTTP iniciada en puerto %d", port)
|
|
// if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
|
// log.Fatalf("Error en servidor HTTP: %v", err)
|
|
// }
|
|
// }()
|
|
//
|
|
// return srv
|
|
//}
|
|
|
|
// // runAllServices ejecuta todos los servicios de manera concurrente.
|
|
// func runAllServices(ctx context.Context, services []services.SoapService) []error {
|
|
// var wg sync.WaitGroup
|
|
// var mu sync.Mutex
|
|
// var errors []error
|
|
|
|
// for _, svc := range services {
|
|
// s := svc
|
|
// wg.Add(1)
|
|
// go func() {
|
|
// defer wg.Done()
|
|
// serviceCtx, cancel := context.WithCancel(ctx)
|
|
// defer cancel()
|
|
// // if err := s.Execute(serviceCtx); err != nil {
|
|
// if err := s.Execute(serviceCtx, nil); err != nil { //ariel agrego:request
|
|
// mu.Lock()
|
|
// errors = append(errors, err)
|
|
// mu.Unlock()
|
|
// }
|
|
// }()
|
|
// }
|
|
// wg.Wait()
|
|
// log.Println("Todos los servicios han sido ejecutados")
|
|
// return errors
|
|
// }
|