124 lines
3.8 KiB
Cheetah
124 lines
3.8 KiB
Cheetah
package main
|
|
|
|
import (
|
|
"context"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
|
|
"github.com/payne8/go-libsql-dual-driver"
|
|
"github.com/rs/cors"
|
|
sqlite "github.com/ytsruh/gorm-libsql"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/credentials/insecure"
|
|
"google.golang.org/grpc/reflection"
|
|
"gorm.io/gorm"
|
|
pb "{{ .AppName }}/gen/go"
|
|
)
|
|
|
|
func main() {
|
|
logger := log.New(os.Stdout, "{{ .AppName }} ", log.LstdFlags)
|
|
primaryUrl := os.Getenv("LIBSQL_DATABASE_URL")
|
|
authToken := os.Getenv("LIBSQL_AUTH_TOKEN")
|
|
|
|
tdb, err := libsqldb.NewLibSqlDB(
|
|
primaryUrl,
|
|
// libsqldb.WithMigrationFiles(migrationFiles),
|
|
libsqldb.WithAuthToken(authToken),
|
|
libsqldb.WithLocalDBName("local.db"), // will not be used for remote-only
|
|
)
|
|
if err != nil {
|
|
logger.Printf("failed to open db %s: %s", primaryUrl, err)
|
|
log.Fatalln(err)
|
|
return
|
|
}
|
|
|
|
// Instantiate the gorm ORM
|
|
gormDB, err := gorm.Open(sqlite.New(sqlite.Config{Conn: tdb.DB}), &gorm.Config{})
|
|
if err != nil {
|
|
logger.Printf("failed to open gorm db %s: %s", primaryUrl, err)
|
|
log.Fatalln(err)
|
|
return
|
|
}
|
|
|
|
// Uncomment these lines if you need automatic migration
|
|
// err = gormDB.AutoMigrate(&pb.UserORM{})
|
|
// if err != nil {
|
|
// logger.Printf("failed to migrate user: %s", err)
|
|
// log.Fatalln(err)
|
|
// return
|
|
// }
|
|
// err = gormDB.AutoMigrate(&pb.ProductORM{})
|
|
// if err != nil {
|
|
// logger.Printf("failed to migrate product: %s", err)
|
|
// log.Fatalln(err)
|
|
// return
|
|
// }
|
|
|
|
handlers := pb.{{ .AppNameCaps }}DefaultServer{
|
|
DB: gormDB,
|
|
}
|
|
|
|
// Create the gRPC server with a middleware for logging (or future authentication)
|
|
grpcServer := grpc.NewServer(grpc.ChainUnaryInterceptor(
|
|
func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
|
|
// TODO: this is an example of a middleware - we will use this for authentication
|
|
// we will have a function that checks the token and a switch statement that checks if the method is public or not
|
|
logger.Printf("request: %s", info.FullMethod)
|
|
return handler(ctx, req)
|
|
},
|
|
))
|
|
pb.Register{{ .AppNameCaps }}Server(grpcServer, &handlers)
|
|
reflection.Register(grpcServer)
|
|
|
|
// Start the gRPC server on port 9000
|
|
grpcAddr := ":9000"
|
|
lis, err := net.Listen("tcp", grpcAddr)
|
|
if err != nil {
|
|
logger.Fatalf("failed to listen on %s: %v", grpcAddr, err)
|
|
}
|
|
go func() {
|
|
logger.Printf("gRPC server listening on %s", grpcAddr)
|
|
if err := grpcServer.Serve(lis); err != nil {
|
|
logger.Fatalf("failed to serve gRPC: %v", err)
|
|
}
|
|
}()
|
|
|
|
// Set up the grpc-gateway mux
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
gwmux := runtime.NewServeMux()
|
|
opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
|
|
grpcEndpoint := "localhost" + grpcAddr
|
|
err = pb.Register{{ .AppNameCaps }}HandlerFromEndpoint(ctx, gwmux, grpcEndpoint, opts)
|
|
if err != nil {
|
|
logger.Fatalf("failed to register gateway: %v", err)
|
|
}
|
|
|
|
withCors := cors.New(cors.Options{
|
|
AllowedOrigins: []string{"http://localhost:*"}, // TODO: change this to the actual domain
|
|
AllowedMethods: []string{"GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"},
|
|
AllowedHeaders: []string{"ACCEPT", "Authorization", "Content-Type", "X-CSRF-Token"},
|
|
ExposedHeaders: []string{"Link"},
|
|
AllowCredentials: true,
|
|
MaxAge: 300,
|
|
}).Handler(gwmux)
|
|
|
|
// Start the HTTP gateway on port 8080
|
|
httpAddr := ":8080"
|
|
logger.Printf("HTTP gateway listening on %s", httpAddr)
|
|
server := &http.Server{
|
|
Addr: httpAddr,
|
|
Handler: gwmux,
|
|
ReadTimeout: 5 * time.Second,
|
|
WriteTimeout: 10 * time.Second,
|
|
}
|
|
if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
|
logger.Fatalf("failed to serve HTTP gateway: %v", err)
|
|
}
|
|
}
|