planner
This commit is contained in:
matst80
614
cmd/planner/main.go
Normal file
614
cmd/planner/main.go
Normal file
@@ -0,0 +1,614 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"container/heap"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"sort"
|
||||
"strconv"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"git.tornberg.me/go-gtfs/pkg/reader"
|
||||
"git.tornberg.me/go-gtfs/pkg/types"
|
||||
)
|
||||
|
||||
// TripPlanner handles preprocessed transit data for efficient routing
|
||||
type TripPlanner struct {
|
||||
stops map[string]*types.Stop
|
||||
trips map[string]*types.Trip
|
||||
routes map[string]*types.Route
|
||||
agencies map[string]*types.Agency
|
||||
transfers []types.Transfer
|
||||
stopTimes map[string][]types.StopTime
|
||||
graph map[string][]Edge
|
||||
weightedStops map[string][]Connection
|
||||
}
|
||||
|
||||
type StopWithPossibleConnections struct {
|
||||
*types.Stop
|
||||
PossibleConnections []Connection
|
||||
}
|
||||
|
||||
type Connection struct {
|
||||
*types.Stop
|
||||
Distance float64
|
||||
Time time.Duration
|
||||
}
|
||||
|
||||
const (
|
||||
transferPenalty = 90 * time.Minute
|
||||
maxTransfers = 4
|
||||
maxWaitBetweenTrips = 1 * time.Hour
|
||||
//trajectoryAngleTolerance = 220.0
|
||||
maxTravelDuration = 12 * time.Hour
|
||||
maxDetourFactor = 2
|
||||
)
|
||||
|
||||
// NewTripPlanner creates a new trip planner instance
|
||||
func NewTripPlanner() *TripPlanner {
|
||||
return &TripPlanner{
|
||||
stops: make(map[string]*types.Stop),
|
||||
trips: make(map[string]*types.Trip),
|
||||
routes: make(map[string]*types.Route),
|
||||
agencies: make(map[string]*types.Agency),
|
||||
stopTimes: make(map[string][]types.StopTime),
|
||||
graph: make(map[string][]Edge),
|
||||
weightedStops: make(map[string][]Connection),
|
||||
}
|
||||
}
|
||||
|
||||
// LoadData loads all GTFS data
|
||||
func (tp *TripPlanner) LoadData(dataDir string) error {
|
||||
files := []string{"agency", "routes", "stops", "trips", "stop_times", "transfers"}
|
||||
for _, file := range files {
|
||||
|
||||
f, err := os.Open(dataDir + "/" + file + ".txt")
|
||||
if err != nil {
|
||||
log.Fatalf("failed to open %s: %v", file, err)
|
||||
}
|
||||
|
||||
switch file {
|
||||
case "agency":
|
||||
err = reader.ParseAgencies(f, func(a types.Agency) {
|
||||
tp.agencies[a.AgencyID] = &a
|
||||
})
|
||||
case "routes":
|
||||
err = reader.ParseRoutes(f, func(r types.Route) {
|
||||
tp.routes[r.RouteID] = &r
|
||||
if ag, ok := tp.agencies[r.AgencyID]; ok {
|
||||
r.Agency = ag
|
||||
ag.AddRoute(&r)
|
||||
}
|
||||
})
|
||||
case "stops":
|
||||
err = reader.ParseStops(f, func(s types.Stop) {
|
||||
tp.stops[s.StopID] = &s
|
||||
})
|
||||
case "trips":
|
||||
err = reader.ParseTrips(f, func(t types.Trip) {
|
||||
trip := t
|
||||
if route, ok := tp.routes[trip.RouteID]; ok {
|
||||
trip.SetRoute(route)
|
||||
route.AddTrip(&trip)
|
||||
} else {
|
||||
log.Printf("route %s not found", trip.RouteID)
|
||||
}
|
||||
if agency, ok := tp.agencies[trip.AgencyID]; ok {
|
||||
trip.Agency = agency
|
||||
} else {
|
||||
log.Printf("agency %s not found", trip.AgencyID)
|
||||
}
|
||||
tp.trips[trip.TripID] = &trip
|
||||
})
|
||||
case "stop_times":
|
||||
err = reader.ParseStopTimes(f, func(st types.StopTime) {
|
||||
stop, ok := tp.stops[st.StopID]
|
||||
if ok {
|
||||
st.SetStop(stop)
|
||||
} else {
|
||||
log.Printf("stop %s not found", st.StopID)
|
||||
|
||||
}
|
||||
trp, ok := tp.trips[st.TripID]
|
||||
if !ok {
|
||||
log.Printf("trip %s not found", st.TripID)
|
||||
|
||||
} else {
|
||||
stop.AddTrip(trp)
|
||||
trp.AddStopTime(&st)
|
||||
}
|
||||
|
||||
})
|
||||
case "transfers":
|
||||
err = reader.ParseTransfers(f, func(tr types.Transfer) {
|
||||
tp.transfers = append(tp.transfers, tr)
|
||||
stop, ok := tp.stops[tr.FromStopID]
|
||||
if ok {
|
||||
stop.AddTransfer(&tr)
|
||||
} else {
|
||||
log.Printf("stop %s not found for transfer", tr.FromStopID)
|
||||
}
|
||||
|
||||
})
|
||||
}
|
||||
if err != nil {
|
||||
log.Printf("failed to parse %s: %v", file, err)
|
||||
}
|
||||
f.Close()
|
||||
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Preprocess builds the routing graph and precomputes routes
|
||||
func (tp *TripPlanner) Preprocess() error {
|
||||
|
||||
if hosjo, ok := tp.stops["740025287"]; ok {
|
||||
trips := hosjo.GetTripsAfter(time.Now())
|
||||
for _, trip := range trips {
|
||||
log.Printf("Trip %s (%s):", trip.TripShortName, trip.TripHeadsign)
|
||||
for stop := range trip.GetDirectPossibleDestinations(hosjo, time.Now()) {
|
||||
log.Printf("- Stop %s at %s", stop.Stop.StopName, stop.DepartureTime)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Build graph with trip edges
|
||||
for tripID, sts := range tp.stopTimes {
|
||||
sort.Slice(sts, func(i, j int) bool {
|
||||
return sts[i].StopSequence < sts[j].StopSequence
|
||||
})
|
||||
for i := 0; i < len(sts)-1; i++ {
|
||||
from := sts[i].StopID
|
||||
to := sts[i+1].StopID
|
||||
departure := parseTime(sts[i].DepartureTime)
|
||||
arrival := parseTime(sts[i+1].ArrivalTime)
|
||||
timeDiff := arrival - departure
|
||||
if timeDiff > 0 {
|
||||
tp.graph[from] = append(tp.graph[from], Edge{To: to, TripID: tripID, Time: timeDiff, DepartureTime: departure})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Add transfer edges
|
||||
for _, tr := range tp.transfers {
|
||||
if tr.TransferType == 2 { // minimum transfer time
|
||||
tp.graph[tr.FromStopID] = append(tp.graph[tr.FromStopID], Edge{
|
||||
To: tr.ToStopID,
|
||||
TripID: "transfer",
|
||||
Time: float64(tr.MinTransferTime),
|
||||
DepartureTime: 0,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
tp.stopTimes = nil
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// FindRoute finds the best route between two stops starting at the given time
|
||||
func (tp *TripPlanner) FindRoute(from, to string, when time.Time) *Route {
|
||||
routes := tp.FindRoutes(from, to, when, 1)
|
||||
if len(routes) > 0 {
|
||||
return routes[0]
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// FindRoutes finds the best routes (up to num) between two stops starting at the given time
|
||||
func (tp *TripPlanner) FindRoutes(from, to string, when time.Time, num int) []*Route {
|
||||
var allRoutes []*Route
|
||||
seen := make(map[string]bool) // to avoid duplicates based on departure and arrival times
|
||||
for i := 0; i < num*20 && len(allRoutes) < num; i++ {
|
||||
route := tp.findRoute(from, to, when.Add(time.Duration(i*5)*time.Minute))
|
||||
if route != nil {
|
||||
key := fmt.Sprintf("%d-%d", route.Legs[0].DepartureTime.Unix(), route.Legs[len(route.Legs)-1].ArrivalTime.Unix())
|
||||
if !seen[key] {
|
||||
seen[key] = true
|
||||
allRoutes = append(allRoutes, route)
|
||||
log.Printf("Found route %d: departure %v, arrival %v, duration %v", len(allRoutes), route.Legs[0].DepartureTime, route.Legs[len(route.Legs)-1].ArrivalTime, route.Duration())
|
||||
}
|
||||
}
|
||||
}
|
||||
log.Printf("Total routes found: %d", len(allRoutes))
|
||||
|
||||
return allRoutes
|
||||
}
|
||||
|
||||
// findRoute implements a time-aware Dijkstra algorithm for routing
|
||||
func (tp *TripPlanner) findRoute(start, end string, when time.Time) *Route {
|
||||
startStop := tp.GetStop(start)
|
||||
if startStop == nil {
|
||||
return nil
|
||||
}
|
||||
goalStop := tp.GetStop(end)
|
||||
if goalStop == nil {
|
||||
return nil
|
||||
}
|
||||
maxAllowedDistance := haversine(startStop.StopLat, startStop.StopLon, goalStop.StopLat, goalStop.StopLon) * maxDetourFactor
|
||||
|
||||
arrival := make(map[string]time.Time)
|
||||
cost := make(map[string]time.Time)
|
||||
prev := make(map[string]PathInfo)
|
||||
pq := &priorityQueue{}
|
||||
heap.Init(pq)
|
||||
|
||||
arrival[start] = when
|
||||
cost[start] = when
|
||||
prev[start] = PathInfo{Prev: "", TripID: "", DepartureTime: when, Transfers: 0, LastTrip: "", WaitDuration: 0}
|
||||
heap.Push(pq, &pqItem{Stop: start, Cost: when})
|
||||
|
||||
for pq.Len() > 0 {
|
||||
item := heap.Pop(pq).(*pqItem)
|
||||
current := item.Stop
|
||||
if storedCost, ok := cost[current]; !ok || item.Cost.After(storedCost) {
|
||||
continue
|
||||
}
|
||||
|
||||
currentArrival, ok := arrival[current]
|
||||
if !ok || currentArrival.IsZero() {
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
if current == end {
|
||||
stopsPath := []string{}
|
||||
current := end
|
||||
visited := make(map[string]bool)
|
||||
for current != "" {
|
||||
if visited[current] {
|
||||
break
|
||||
}
|
||||
visited[current] = true
|
||||
stopsPath = append([]string{current}, stopsPath...)
|
||||
if current == start {
|
||||
break
|
||||
}
|
||||
info, ok := prev[current]
|
||||
if !ok || info.Prev == "" {
|
||||
break
|
||||
}
|
||||
current = info.Prev
|
||||
}
|
||||
legs := []Leg{}
|
||||
var currentLeg *Leg
|
||||
for i := 0; i < len(stopsPath)-1; i++ {
|
||||
from := stopsPath[i]
|
||||
to := stopsPath[i+1]
|
||||
tripID := prev[to].TripID
|
||||
if tripID != "transfer" {
|
||||
if currentLeg == nil || currentLeg.TripID != tripID {
|
||||
if currentLeg != nil {
|
||||
legs = append(legs, *currentLeg)
|
||||
}
|
||||
trip := tp.GetTrip(tripID)
|
||||
route := tp.GetRoute(trip.RouteID)
|
||||
currentLeg = &Leg{
|
||||
TripID: tripID,
|
||||
From: from,
|
||||
FromStop: tp.GetStop(from),
|
||||
Trip: trip,
|
||||
Agency: tp.GetAgency(route.AgencyID),
|
||||
Route: route,
|
||||
Stops: []string{from},
|
||||
DepartureTime: prev[to].DepartureTime,
|
||||
}
|
||||
}
|
||||
currentLeg.To = to
|
||||
currentLeg.ToStop = tp.GetStop(to)
|
||||
currentLeg.Stops = append(currentLeg.Stops, to)
|
||||
currentLeg.ArrivalTime = arrival[to]
|
||||
}
|
||||
}
|
||||
if currentLeg != nil {
|
||||
currentLeg.To = stopsPath[len(stopsPath)-1]
|
||||
currentLeg.ToStop = tp.GetStop(currentLeg.To)
|
||||
currentLeg.ArrivalTime = arrival[stopsPath[len(stopsPath)-1]]
|
||||
legs = append(legs, *currentLeg)
|
||||
}
|
||||
|
||||
return &Route{Legs: legs}
|
||||
}
|
||||
|
||||
currentStop := tp.GetStop(current)
|
||||
if currentStop == nil {
|
||||
continue
|
||||
}
|
||||
//currentBearing := bearing(currentStop.StopLat, currentStop.StopLon, goalStop.StopLat, goalStop.StopLon)
|
||||
|
||||
for _, edge := range tp.graph[current] {
|
||||
if edge.To == current {
|
||||
continue
|
||||
}
|
||||
if info, ok := prev[current]; ok && info.Prev == edge.To && info.TripID == edge.TripID {
|
||||
continue
|
||||
}
|
||||
nextStop := tp.GetStop(edge.To)
|
||||
if nextStop == nil {
|
||||
continue
|
||||
}
|
||||
|
||||
distanceToGoal := haversine(nextStop.StopLat, nextStop.StopLon, goalStop.StopLat, goalStop.StopLon)
|
||||
if distanceToGoal > maxAllowedDistance {
|
||||
continue
|
||||
}
|
||||
|
||||
// if edge.TripID != "transfer" {
|
||||
// edgeBearing := bearing(currentStop.StopLat, currentStop.StopLon, nextStop.StopLat, nextStop.StopLon)
|
||||
// if angleDifference(currentBearing, edgeBearing) > trajectoryAngleTolerance {
|
||||
// continue
|
||||
// }
|
||||
// }
|
||||
|
||||
var arrivalTime time.Time
|
||||
var departureTime time.Time
|
||||
var waitDuration time.Duration
|
||||
|
||||
if edge.TripID == "transfer" {
|
||||
waitDuration = time.Duration(edge.Time) * time.Second
|
||||
if waitDuration > maxWaitBetweenTrips {
|
||||
continue
|
||||
}
|
||||
arrivalTime = currentArrival.Add(waitDuration)
|
||||
departureTime = arrivalTime
|
||||
} else {
|
||||
depSec := edge.DepartureTime
|
||||
day := currentArrival.Truncate(24 * time.Hour)
|
||||
departure := day.Add(time.Duration(depSec) * time.Second)
|
||||
if departure.Before(currentArrival) {
|
||||
departure = departure.Add(24 * time.Hour)
|
||||
}
|
||||
if departure.After(currentArrival) || departure.Equal(currentArrival) {
|
||||
arrivalTime = departure.Add(time.Duration(edge.Time) * time.Second)
|
||||
departureTime = departure
|
||||
waitDuration = departureTime.Sub(currentArrival)
|
||||
if waitDuration > maxWaitBetweenTrips {
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
if arrivalTime.Sub(when) > maxTravelDuration {
|
||||
continue
|
||||
}
|
||||
|
||||
currentTransfers := prev[current].Transfers
|
||||
lastTrip := prev[current].LastTrip
|
||||
newTransfers := currentTransfers
|
||||
var newLastTrip string
|
||||
if edge.TripID == "transfer" {
|
||||
newLastTrip = lastTrip
|
||||
} else {
|
||||
newLastTrip = edge.TripID
|
||||
if lastTrip != "" && lastTrip != edge.TripID {
|
||||
newTransfers++
|
||||
}
|
||||
}
|
||||
if newTransfers > maxTransfers {
|
||||
continue
|
||||
}
|
||||
|
||||
costTime := arrivalTime
|
||||
if edge.TripID != "transfer" && lastTrip != "" && lastTrip != edge.TripID {
|
||||
costTime = costTime.Add(transferPenalty)
|
||||
}
|
||||
|
||||
existingCost, hasCost := cost[edge.To]
|
||||
existingArrival := arrival[edge.To]
|
||||
existingInfo, havePrev := prev[edge.To]
|
||||
shouldRelax := !hasCost || existingCost.IsZero() || costTime.Before(existingCost)
|
||||
if !shouldRelax && costTime.Equal(existingCost) {
|
||||
if existingArrival.IsZero() || arrivalTime.Before(existingArrival) {
|
||||
shouldRelax = true
|
||||
} else if havePrev && arrivalTime.Equal(existingArrival) {
|
||||
if newTransfers < existingInfo.Transfers {
|
||||
shouldRelax = true
|
||||
} else if waitDuration < existingInfo.WaitDuration {
|
||||
shouldRelax = true
|
||||
}
|
||||
}
|
||||
}
|
||||
if shouldRelax {
|
||||
ancestor := current
|
||||
createsCycle := false
|
||||
for ancestor != "" {
|
||||
if ancestor == edge.To {
|
||||
createsCycle = true
|
||||
break
|
||||
}
|
||||
info, ok := prev[ancestor]
|
||||
if !ok {
|
||||
break
|
||||
}
|
||||
ancestor = info.Prev
|
||||
}
|
||||
if createsCycle {
|
||||
continue
|
||||
}
|
||||
arrival[edge.To] = arrivalTime
|
||||
cost[edge.To] = costTime
|
||||
prev[edge.To] = PathInfo{Prev: current, TripID: edge.TripID, DepartureTime: departureTime, Transfers: newTransfers, LastTrip: newLastTrip, WaitDuration: waitDuration}
|
||||
heap.Push(pq, &pqItem{Stop: edge.To, Cost: costTime})
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (tp *TripPlanner) GetRoute(routeId string) *types.Route {
|
||||
if routeId == "" {
|
||||
return nil
|
||||
}
|
||||
route, ok := tp.routes[routeId]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return route
|
||||
}
|
||||
|
||||
func (tp *TripPlanner) GetAgency(agencyId string) *types.Agency {
|
||||
if agencyId == "" {
|
||||
return nil
|
||||
}
|
||||
agency, ok := tp.agencies[agencyId]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return agency
|
||||
}
|
||||
|
||||
func (tp *TripPlanner) GetTrip(tripId string) *types.Trip {
|
||||
if tripId == "" {
|
||||
return nil
|
||||
}
|
||||
trip, ok := tp.trips[tripId]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return trip
|
||||
}
|
||||
|
||||
func (tp *TripPlanner) GetStop(prev string) *types.Stop {
|
||||
if prev == "" {
|
||||
return nil
|
||||
}
|
||||
stop, ok := tp.stops[prev]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return stop
|
||||
}
|
||||
|
||||
type Edge struct {
|
||||
To string
|
||||
TripID string
|
||||
Time float64
|
||||
DepartureTime float64
|
||||
}
|
||||
|
||||
type TripDetail struct {
|
||||
RouteShortName string `json:"route_short_name"`
|
||||
AgencyName string `json:"agency_name"`
|
||||
Stops []string `json:"stops"`
|
||||
}
|
||||
|
||||
type Leg struct {
|
||||
From string `json:"-"`
|
||||
FromStop *types.Stop `json:"from"`
|
||||
To string `json:"-"`
|
||||
ToStop *types.Stop `json:"to"`
|
||||
TripID string `json:"-"`
|
||||
Trip *types.Trip `json:"trip"`
|
||||
Stops []string `json:"stops"`
|
||||
Agency *types.Agency `json:"agency"`
|
||||
Route *types.Route `json:"route"`
|
||||
DepartureTime time.Time `json:"departure_time"`
|
||||
ArrivalTime time.Time `json:"arrival_time"`
|
||||
}
|
||||
|
||||
type Route struct {
|
||||
Legs []Leg `json:"legs"`
|
||||
}
|
||||
|
||||
func (r *Route) EndTime() time.Time {
|
||||
if len(r.Legs) == 0 {
|
||||
return time.Time{}
|
||||
}
|
||||
return r.Legs[len(r.Legs)-1].ArrivalTime
|
||||
}
|
||||
|
||||
func (r *Route) StartTime() time.Time {
|
||||
if len(r.Legs) == 0 {
|
||||
return time.Time{}
|
||||
}
|
||||
return r.Legs[0].DepartureTime
|
||||
}
|
||||
|
||||
func (r *Route) Duration() time.Duration {
|
||||
if len(r.Legs) == 0 {
|
||||
return 0
|
||||
}
|
||||
return r.Legs[len(r.Legs)-1].ArrivalTime.Sub(r.Legs[0].DepartureTime)
|
||||
}
|
||||
|
||||
type PathInfo struct {
|
||||
Prev string
|
||||
TripID string
|
||||
DepartureTime time.Time
|
||||
Transfers int
|
||||
LastTrip string
|
||||
WaitDuration time.Duration
|
||||
}
|
||||
|
||||
func main() {
|
||||
tp := NewTripPlanner()
|
||||
wg := &sync.WaitGroup{}
|
||||
if err := tp.LoadData("data"); err != nil {
|
||||
fmt.Printf("Failed to load data: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
wg.Wait()
|
||||
if err := tp.Preprocess(); err != nil {
|
||||
fmt.Printf("Failed to preprocess data: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
http.HandleFunc("/api/stops", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
w.Header().Set("Access-Control-Allow-Methods", "GET")
|
||||
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
||||
stopList := []types.Stop{}
|
||||
for _, s := range tp.stops {
|
||||
if _, hasConnections := tp.graph[s.StopID]; hasConnections {
|
||||
stopList = append(stopList, *s)
|
||||
}
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(stopList)
|
||||
})
|
||||
|
||||
http.HandleFunc("/api/route", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
w.Header().Set("Access-Control-Allow-Methods", "GET")
|
||||
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
||||
from := r.URL.Query().Get("from")
|
||||
to := r.URL.Query().Get("to")
|
||||
whenStr := r.URL.Query().Get("when")
|
||||
numStr := r.URL.Query().Get("num")
|
||||
num := 3
|
||||
if numStr != "" {
|
||||
if parsed, err := strconv.Atoi(numStr); err == nil && parsed > 0 {
|
||||
num = parsed
|
||||
}
|
||||
}
|
||||
when := time.Now()
|
||||
if whenStr != "" {
|
||||
if parsed, err := time.Parse(time.RFC3339, whenStr); err == nil {
|
||||
when = parsed
|
||||
}
|
||||
}
|
||||
if from == "" || to == "" {
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
json.NewEncoder(w).Encode(map[string]string{"error": "from and to parameters required"})
|
||||
return
|
||||
}
|
||||
routes := tp.FindRoutes(from, to, when, num)
|
||||
if len(routes) == 0 {
|
||||
w.WriteHeader(http.StatusNotFound)
|
||||
json.NewEncoder(w).Encode(map[string]string{"error": "no route found"})
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
json.NewEncoder(w).Encode(routes)
|
||||
})
|
||||
log.Printf("Listening on 8080")
|
||||
http.ListenAndServe(":8080", nil)
|
||||
}
|
||||
Reference in New Issue
Block a user