generated from VLADIMIR/template
121 lines
3.0 KiB
Go
121 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"embed"
|
|
"io/fs"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"pinned_message/internal/app"
|
|
"pinned_message/internal/config"
|
|
"pinned_message/internal/modules/data_parser"
|
|
"pinned_message/internal/modules/date_parser"
|
|
"pinned_message/internal/services"
|
|
"pinned_message/internal/services/schedule_parser"
|
|
"pinned_message/internal/services/schedule_storage"
|
|
proto "pinned_message/proto"
|
|
|
|
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/credentials/insecure"
|
|
)
|
|
|
|
const (
|
|
tcpPort = ":8200"
|
|
gwPort = ":8210"
|
|
clientPort = ":8220"
|
|
)
|
|
|
|
//go:embed static/user/*
|
|
var userFS embed.FS
|
|
|
|
func main() {
|
|
// Create a listener on TCP port
|
|
lis, err := net.Listen("tcp", tcpPort)
|
|
if err != nil {
|
|
log.Fatalln("Failed to listen:", err)
|
|
}
|
|
|
|
// Create a gRPC server object
|
|
s := grpc.NewServer()
|
|
|
|
ctx := context.Background()
|
|
scheduleStorage := schedule_storage.NewScheduleStorage(config.GetScheduleFilepath())
|
|
scheduleParser := schedule_parser.NewScheduleParser(
|
|
data_parser.NewGoogleTableScheduleParser(),
|
|
date_parser.NewDateParser(),
|
|
scheduleStorage,
|
|
)
|
|
go func() {
|
|
scheduleParser.Run(ctx)
|
|
}()
|
|
|
|
// Attach the Greeter service to the server
|
|
proto.RegisterPinnedMessageServer(
|
|
s,
|
|
app.NewServer(
|
|
services.NewServices(
|
|
scheduleStorage,
|
|
),
|
|
),
|
|
)
|
|
// Serve gRPC server
|
|
log.Println("Serving gRPC on 0.0.0.0" + tcpPort)
|
|
go func() {
|
|
log.Fatalln(s.Serve(lis))
|
|
}()
|
|
|
|
// Create a client connection to the gRPC server we just started
|
|
// This is where the gRPC-Gateway proxies the requests
|
|
conn, err := grpc.NewClient(
|
|
"0.0.0.0"+tcpPort,
|
|
grpc.WithTransportCredentials(insecure.NewCredentials()),
|
|
)
|
|
if err != nil {
|
|
log.Fatalln("Failed to dial server:", err)
|
|
}
|
|
|
|
gwmux := runtime.NewServeMux()
|
|
// Register Greeter
|
|
err = proto.RegisterPinnedMessageHandler(context.Background(), gwmux, conn)
|
|
if err != nil {
|
|
log.Fatalln("Failed to register gateway:", err)
|
|
}
|
|
|
|
gwServer := &http.Server{
|
|
Addr: gwPort,
|
|
Handler: cors(gwmux),
|
|
}
|
|
|
|
// Serve gRPC-Gateway server
|
|
log.Println("Serving gRPC-Gateway on http://0.0.0.0" + gwPort)
|
|
go func() {
|
|
log.Fatalln(gwServer.ListenAndServe())
|
|
}()
|
|
|
|
muxUser := http.NewServeMux()
|
|
subUserFS, err := fs.Sub(userFS, "static/user")
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
fileServerUser := http.FileServer(http.FS(subUserFS))
|
|
muxUser.Handle("/", fileServerUser)
|
|
|
|
// Serve admin web server
|
|
log.Println("Serving user web on http://0.0.0.0" + clientPort)
|
|
log.Fatalln(http.ListenAndServe(clientPort, muxUser))
|
|
}
|
|
|
|
func cors(h http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, Authorization, ResponseType, X-Id, X-Password")
|
|
if r.Method == "OPTIONS" {
|
|
return
|
|
}
|
|
h.ServeHTTP(w, r)
|
|
})
|
|
}
|