242 lines
10 KiB
Go
242 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"neuralhunt/internal/customer"
|
|
"neuralhunt/internal/customerui"
|
|
)
|
|
|
|
func loadDotEnv(path string) {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer f.Close()
|
|
s := bufio.NewScanner(f)
|
|
for s.Scan() {
|
|
line := strings.TrimSpace(s.Text())
|
|
if line == "" || strings.HasPrefix(line, "#") {
|
|
continue
|
|
}
|
|
if strings.HasPrefix(line, "export ") {
|
|
line = strings.TrimSpace(strings.TrimPrefix(line, "export "))
|
|
}
|
|
k, v, ok := strings.Cut(line, "=")
|
|
if !ok {
|
|
continue
|
|
}
|
|
k, v = strings.TrimSpace(k), strings.TrimSpace(v)
|
|
if k == "" {
|
|
continue
|
|
}
|
|
if _, exists := os.LookupEnv(k); exists {
|
|
continue
|
|
}
|
|
if len(v) >= 2 && ((v[0] == '"' && v[len(v)-1] == '"') || (v[0] == '\'' && v[len(v)-1] == '\'')) {
|
|
v = v[1 : len(v)-1]
|
|
}
|
|
_ = os.Setenv(k, v)
|
|
}
|
|
}
|
|
func env(k, d string) string {
|
|
if v := strings.TrimSpace(os.Getenv(k)); v != "" {
|
|
return v
|
|
}
|
|
return d
|
|
}
|
|
func boolEnv(k string, d bool) bool {
|
|
v := strings.ToLower(strings.TrimSpace(os.Getenv(k)))
|
|
if v == "" {
|
|
return d
|
|
}
|
|
return v == "1" || v == "true" || v == "yes" || v == "on"
|
|
}
|
|
func intEnv(k string, d int) int {
|
|
v, err := strconv.Atoi(strings.TrimSpace(os.Getenv(k)))
|
|
if err != nil {
|
|
return d
|
|
}
|
|
return v
|
|
}
|
|
func floatEnv(k string, d float64) float64 {
|
|
v, err := strconv.ParseFloat(strings.TrimSpace(os.Getenv(k)), 64)
|
|
if err != nil {
|
|
return d
|
|
}
|
|
return v
|
|
}
|
|
func durationEnv(k string, d time.Duration) time.Duration {
|
|
v := strings.TrimSpace(os.Getenv(k))
|
|
if v == "" {
|
|
return d
|
|
}
|
|
if x, err := time.ParseDuration(v); err == nil {
|
|
return x
|
|
}
|
|
return d
|
|
}
|
|
|
|
// CS_CREDIT_PACKAGES format: id:amount_cents:CURRENCY:credits;...
|
|
// Example: starter:499:EUR:60;plus:1999:EUR:300
|
|
func packagesFromEnv() ([]customer.CreditPackage, error) {
|
|
raw := env("CS_CREDIT_PACKAGES", "starter:499:EUR:60;plus:1999:EUR:300;power:4999:EUR:900")
|
|
var out []customer.CreditPackage
|
|
for _, part := range strings.Split(raw, ";") {
|
|
part = strings.TrimSpace(part)
|
|
if part == "" {
|
|
continue
|
|
}
|
|
f := strings.Split(part, ":")
|
|
if len(f) != 4 {
|
|
return nil, fmt.Errorf("invalid CS_CREDIT_PACKAGES entry %q", part)
|
|
}
|
|
cents, err := strconv.ParseInt(f[1], 10, 64)
|
|
if err != nil || cents <= 0 {
|
|
return nil, fmt.Errorf("invalid package cents %q", f[1])
|
|
}
|
|
credits, err := strconv.ParseFloat(f[3], 64)
|
|
if err != nil || credits <= 0 {
|
|
return nil, fmt.Errorf("invalid package credits %q", f[3])
|
|
}
|
|
out = append(out, customer.CreditPackage{ID: strings.TrimSpace(f[0]), AmountCents: cents, Currency: strings.ToUpper(strings.TrimSpace(f[2])), CreditsMicros: int64(credits*1_000_000 + 0.5)})
|
|
}
|
|
if len(out) == 0 {
|
|
return nil, fmt.Errorf("no credit packages configured")
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func validate(cfg customer.Config) error {
|
|
shared := strings.TrimSpace(cfg.SharedSecret)
|
|
if len(shared) < 32 || strings.Contains(strings.ToLower(shared), "replace-with") || strings.Contains(strings.ToLower(shared), "change-me") {
|
|
return fmt.Errorf("CUSTOMER_SERVICE_SHARED_SECRET must be a unique random value of at least 32 characters; example placeholders are rejected")
|
|
}
|
|
adminPass := strings.TrimSpace(cfg.AdminPassword)
|
|
if len(adminPass) < 16 || strings.Contains(strings.ToLower(adminPass), "replace-with") || strings.Contains(strings.ToLower(adminPass), "change-me") {
|
|
return fmt.Errorf("CS_ADMIN_PASSWORD must be a unique value of at least 16 characters; example placeholders are rejected")
|
|
}
|
|
if cfg.PublicBaseURL == "" {
|
|
return fmt.Errorf("CS_PUBLIC_BASE_URL is required (the HTTPS customer portal URL)")
|
|
}
|
|
if cfg.WorkerImage == "" {
|
|
return fmt.Errorf("CS_WORKER_IMAGE is required")
|
|
}
|
|
if cfg.RegistrationPOWBits < 0 || cfg.RegistrationPOWBits > 24 {
|
|
return fmt.Errorf("CS_REGISTRATION_POW_BITS must be between 0 and 24")
|
|
}
|
|
if cfg.NewCustomerCreditsMicros < 0 || cfg.PositiveTipCreditsMicros < 0 {
|
|
return fmt.Errorf("CS_NEW_CUSTOMER_CREDITS and CS_POSITIVE_TIP_CREDITS must be >= 0")
|
|
}
|
|
mode := strings.ToLower(strings.TrimSpace(cfg.WorkerOrchestrationMode))
|
|
if mode == "" {
|
|
mode = "direct"
|
|
}
|
|
if mode != "direct" && mode != "controller" && mode != "hybrid" {
|
|
return fmt.Errorf("CS_WORKER_ORCHESTRATION_MODE must be direct, controller or hybrid")
|
|
}
|
|
if (mode == "controller" || mode == "hybrid") && len(strings.TrimSpace(cfg.ControllerSharedSecret)) < 32 {
|
|
return fmt.Errorf("SERVICE_CONTROLLER_SHARED_SECRET must be at least 32 characters in controller/hybrid mode")
|
|
}
|
|
if _, err := customer.RegistryAuthHeader(cfg.WorkerRegistryUsername, cfg.WorkerRegistryPassword, cfg.WorkerRegistryServer); err != nil {
|
|
return fmt.Errorf("worker registry auth: %w", err)
|
|
}
|
|
if cfg.PayPalEnabled && strings.EqualFold(cfg.PayPalEnvironment, "live") && cfg.PayPalLiveApprovalAck != "I_HAVE_PAYPAL_APPROVAL" {
|
|
log.Printf("WARNING: PayPal live remains disabled until PAYPAL_LIVE_APPROVAL_ACK=I_HAVE_PAYPAL_APPROVAL is set after provider/legal approval")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
loadDotEnv(".env")
|
|
ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer cancel()
|
|
pkgs, err := packagesFromEnv()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
rate := floatEnv("CS_WORKER_CREDITS_PER_MINUTE", 1.0)
|
|
if rate <= 0 {
|
|
log.Fatal("CS_WORKER_CREDITS_PER_MINUTE must be > 0")
|
|
}
|
|
cfg := customer.Config{
|
|
PublicAddr: env("CS_HTTP_ADDR", ":8090"), AdminAddr: env("CS_ADMIN_HTTP_ADDR", ":8091"), InternalAddr: env("CS_INTERNAL_ADDR", ":8092"),
|
|
PublicBaseURL: strings.TrimRight(env("CS_PUBLIC_BASE_URL", ""), "/"), GamePublicURL: env("CS_GAME_PUBLIC_URL", "http://127.0.0.1:8080"), GameAdminURL: env("CS_GAME_ADMIN_URL", "http://127.0.0.1:8081"), SharedSecret: env("CUSTOMER_SERVICE_SHARED_SECRET", ""),
|
|
DockerHost: env("DOCKER_HOST", "unix:///var/run/docker.sock"), WorkerImage: env("CS_WORKER_IMAGE", "neuralhunt-worker:local"), WorkerEntrypoint: env("CS_WORKER_ENTRYPOINT", ""), WorkerNetwork: env("CS_WORKER_NETWORK", "neuralhunt_backend"), WorkerRegisterURL: env("CS_WORKER_REGISTER_URL", "http://customer-service:8092/internal/workers/register"), WorkerOrchestrationMode: env("CS_WORKER_ORCHESTRATION_MODE", "direct"), ControllerSharedSecret: env("SERVICE_CONTROLLER_SHARED_SECRET", ""), ControllerOfflineAfter: durationEnv("CS_CONTROLLER_OFFLINE_AFTER", 45*time.Second), WorkerAutoPull: boolEnv("CS_WORKER_AUTO_PULL", true), WorkerRegistryUsername: env("CS_WORKER_REGISTRY_USERNAME", ""), WorkerRegistryPassword: env("CS_WORKER_REGISTRY_PASSWORD", ""), WorkerRegistryServer: env("CS_WORKER_REGISTRY_SERVER", ""), WorkerRateMicrosPerMinute: int64(rate*1_000_000 + 0.5), MaxWorkersPerCustomer: intEnv("CS_MAX_WORKERS_PER_CUSTOMER", 20), MaxWorkersGlobal: intEnv("CS_MAX_WORKERS_GLOBAL", 1000), MaxRunningPerCustomer: intEnv("CS_MAX_RUNNING_WORKERS_PER_CUSTOMER", 10), MaxRunningGlobal: intEnv("CS_MAX_RUNNING_WORKERS_GLOBAL", 100),
|
|
SessionTTL: durationEnv("CS_SESSION_TTL", 24*time.Hour), CookieSecure: boolEnv("CS_COOKIE_SECURE", true), AdminCookieSecureMode: env("CS_ADMIN_COOKIE_SECURE", "auto"), AdminUser: env("CS_ADMIN_USER", "admin"), AdminPassword: env("CS_ADMIN_PASSWORD", ""), AllowManualCredits: boolEnv("CS_ALLOW_MANUAL_CREDITS", false),
|
|
LoginEnabled: boolEnv("CS_CUSTOMER_LOGIN_ENABLED", true), RegistrationEnabled: boolEnv("CS_CUSTOMER_REGISTRATION_ENABLED", true), RegistrationPOWBits: intEnv("CS_REGISTRATION_POW_BITS", 16), RegistrationInviteRequired: boolEnv("CS_REGISTRATION_INVITE_REQUIRED", false), NewCustomerCreditsMicros: int64(floatEnv("CS_NEW_CUSTOMER_CREDITS", 0)*1_000_000 + 0.5), PositiveTipCreditsMicros: int64(floatEnv("CS_POSITIVE_TIP_CREDITS", 0)*1_000_000 + 0.5),
|
|
PayPalEnabled: boolEnv("PAYPAL_ENABLED", false), PayPalEnvironment: env("PAYPAL_ENVIRONMENT", "sandbox"), PayPalWebhookID: env("PAYPAL_WEBHOOK_ID", ""), PayPalLiveApprovalAck: env("PAYPAL_LIVE_APPROVAL_ACK", ""), Packages: pkgs,
|
|
}
|
|
if err := validate(cfg); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
st, err := customer.Open(ctx, env("CUSTOMER_SQLITE_PATH", "/customer-data/customer-service.db"))
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
defer st.DB.Close()
|
|
if err := st.RecoverStartingWorkers(ctx); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
mode := strings.ToLower(strings.TrimSpace(cfg.WorkerOrchestrationMode))
|
|
var runtime customer.WorkerRuntime
|
|
if mode == "direct" || mode == "hybrid" || mode == "" {
|
|
dc, err := customer.NewDockerClient(cfg.DockerHost)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
if err := dc.Ping(ctx); err != nil {
|
|
if mode == "direct" || mode == "" {
|
|
log.Fatalf("Docker Engine API unavailable: %v", err)
|
|
}
|
|
log.Printf("WARNING: local Docker fallback unavailable in hybrid mode: %v", err)
|
|
} else {
|
|
runtime = dc
|
|
}
|
|
}
|
|
pp := customer.NewPayPalClient(env("PAYPAL_CLIENT_ID", ""), env("PAYPAL_CLIENT_SECRET", ""), cfg.PayPalEnvironment)
|
|
svc := customer.NewService(st, runtime, pp, cfg)
|
|
if err := svc.SeedPortalSettings(ctx); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
checkCtx, checkCancel := context.WithTimeout(ctx, 5*time.Second)
|
|
if err := svc.CheckGameControlPlane(checkCtx); err != nil {
|
|
log.Printf("WARNING: Hosted-Code/Reward-Control-Plane nicht bereit: %v", err)
|
|
} else {
|
|
log.Printf("Hosted-Code/Reward-Control-Plane bereit: %s", cfg.GameAdminURL)
|
|
}
|
|
checkCancel()
|
|
log.Printf("worker orchestration mode: %s", strings.ToLower(strings.TrimSpace(cfg.WorkerOrchestrationMode)))
|
|
go svc.RunBilling(ctx)
|
|
servers := []*http.Server{
|
|
{Addr: cfg.PublicAddr, Handler: svc.PublicRoutes(customerui.Public()), ReadHeaderTimeout: 5 * time.Second, IdleTimeout: 60 * time.Second},
|
|
{Addr: cfg.AdminAddr, Handler: svc.AdminRoutes(customerui.Admin()), ReadHeaderTimeout: 5 * time.Second, IdleTimeout: 60 * time.Second},
|
|
{Addr: cfg.InternalAddr, Handler: svc.InternalRoutes(), ReadHeaderTimeout: 5 * time.Second, IdleTimeout: 30 * time.Second},
|
|
}
|
|
names := []string{"customer public", "customer admin/private", "customer worker/internal"}
|
|
for i, s := range servers {
|
|
go func(n string, hs *http.Server) {
|
|
log.Printf("%s listener on %s", n, hs.Addr)
|
|
if err := hs.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
|
log.Fatal(err)
|
|
}
|
|
}(names[i], s)
|
|
}
|
|
<-ctx.Done()
|
|
shutdown, done := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer done()
|
|
for _, s := range servers {
|
|
_ = s.Shutdown(shutdown)
|
|
}
|
|
}
|