server.go

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net"
	"net/http"
	"syscall"
	"time"

	"github.com/codeskyblue/iosbridge/usbmuxd"
)

const (
	UsbmuxdPath       = "/var/run/usbmuxd"
	UsbmuxdBackupPath = "/var/run/usbmuxd.bak"
)

type APIResponse struct {
	Success bool        `json:"success"`
	Message string      `json:"message"`
	Data    interface{} `json:"data,omitempty"`
}

func isServerRunning() bool {
	client := http.Client{Timeout: 2 * time.Second}
	resp, err := client.Get(fmt.Sprintf("http://localhost:%d/version", ServerPort))
	if err != nil {
		return false
	}
	defer resp.Body.Close()
	return true
}

type HTTPMuxServer struct {
	muxServer *usbmuxd.Server
	hub       *usbmuxd.UsbmuxHub
}

func NewHTTPMuxServer() *HTTPMuxServer {
	socketAddress := usbmuxd.GetUsbmuxdSocket()
	handler := usbmuxd.NewUsbmuxHub()
	return &HTTPMuxServer{
		muxServer: usbmuxd.NewServer(socketAddress, handler),
		hub:       handler,
	}
}

func (s *HTTPMuxServer) Start() error {
	s.RegisterHTTPHandlers()
	quit := make(chan error)
	go func() {
		quit <- s.muxServer.ListenAndServe()
	}()
	go func() {
		fmt.Println("Starting HTTP server on ", fmt.Sprintf(":%d", ServerPort))
		server := &http.Server{
			Addr:              fmt.Sprintf(":%d", ServerPort),
			ReadTimeout:       30 * time.Second,
			WriteTimeout:      30 * time.Second,
			IdleTimeout:       120 * time.Second,
			ReadHeaderTimeout: 10 * time.Second,
		}
		quit <- server.ListenAndServe()
	}()
	return <-quit
}

func (s *HTTPMuxServer) Stop() {
	s.muxServer.Close()
	s.hub.Close()
}

func (s *HTTPMuxServer) handleConnect(w http.ResponseWriter, r *http.Request) {
	addr := r.URL.Query().Get("addr")
	if addr == "" {
		http.Error(w, "Missing addr parameter", http.StatusBadRequest)
		return
	}
	if err := s.hub.AddSocketAddress(addr); err != nil {
		sendJSONResponse(w, false, err.Error(), nil)
		return
	}
	sendJSONResponse(w, true, "ok", nil)
}

func (s *HTTPMuxServer) handleDisconnect(w http.ResponseWriter, r *http.Request) {
	addr := r.URL.Query().Get("addr")
	if addr == "" {
		sendJSONResponse(w, false, "Missing addr parameter", nil)
		return
	}
	s.hub.RemoveSocketAddress(addr)
	sendJSONResponse(w, true, "ok", nil)
}

func (s *HTTPMuxServer) handleList(w http.ResponseWriter, r *http.Request) {
	sendJSONResponse(w, true, "ok", s.hub.GetDeviceInfoList())
}

func (s *HTTPMuxServer) handleVersion(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	resp, _ := json.Marshal(map[string]interface{}{
		"code": VERSION_CODE,
		"name": VERSION_NAME,
	})
	io.WriteString(w, string(resp)+"\n")
}

func (s *HTTPMuxServer) handleShutdown(w http.ResponseWriter, r *http.Request) {
	sendJSONResponse(w, true, "Shutting down server", nil)

	// Trigger shutdown in a separate goroutine
	go func() {
		time.Sleep(100 * time.Millisecond) // Give time for the response to be sent
		syscall.Kill(syscall.Getpid(), syscall.SIGTERM)
	}()
}

func (s *HTTPMuxServer) RegisterHTTPHandlers() {
	http.HandleFunc("/connect", s.handleConnect)
	http.HandleFunc("/disconnect", s.handleDisconnect)
	http.HandleFunc("/list", s.handleList)
	http.HandleFunc("/version", s.handleVersion)
	http.HandleFunc("/shutdown", s.handleShutdown)
}

func sendJSONResponse(w http.ResponseWriter, success bool, message string, data interface{}) {
	response := APIResponse{
		Success: success,
		Message: message,
		Data:    data,
	}
	// update http status  according to success
	if success {
		w.WriteHeader(http.StatusOK)
	} else {
		w.WriteHeader(http.StatusBadRequest)
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(response)
}

func killServer() error {
	// Try to connect to the server and send a shutdown request
	resp, err := http.Get(fmt.Sprintf("http://localhost:%d/shutdown", ServerPort))
	if err != nil {
		// If we can't connect, the server might not be running
		fmt.Println("Server not running or not reachable")
		return nil
	}
	defer resp.Body.Close()

	fmt.Println("Shutdown request sent, waiting for server to stop...")

	// Wait for the server to stop listening on ServerPort
	maxWaitTime := 10 * time.Second
	waitInterval := 500 * time.Millisecond
	deadline := time.Now().Add(maxWaitTime)

	for time.Now().Before(deadline) {
		// Try to connect to check if server is still running
		_, err := net.DialTimeout("tcp", fmt.Sprintf("localhost:%d", ServerPort), waitInterval)
		if err != nil {
			// If we can't connect, the server has stopped
			fmt.Println("Server stopped successfully")
			return nil
		}
		time.Sleep(waitInterval)
	}

	// If we get here, the server is still running after timeout
	fmt.Println("Server shutdown is taking longer than expected.")
	fmt.Println("If you need to force quit, run: pkill -f iosbridge")
	return nil
}