infoNode.go

// Copyright (c) 2026 Golodnikov Sergey. All rights reserved.
// Use of this source code is governed by a MIT
// license that can be found in the LICENSE file.

package main

// todo: self update

import (
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strings"

	"GS90/infoNode/core/conf"
	"GS90/infoNode/core/handler"
	"GS90/infoNode/core/inspector"
	"GS90/infoNode/core/logger"
	"GS90/infoNode/core/reader"
)

const info string = `
infoNode, version 1.0
https://digiroad.tech

infoNode - hybrid system for creating a website
free software; Copyright (c) 2026 Golodnikov Sergey
`

func init() {
	if path, err := os.Executable(); err != nil {
		log.Fatalln("panic: working dir:", err)
	} else if err = os.Chdir(filepath.Dir(path)); err != nil {
		log.Fatalln("panic: working dir:", err)
	}
}

func main() {
	var (
		c = flag.String("conf", "infoNode.conf", "system configuration file")
		i = flag.Bool("info", false, "print information about infoNode")
	)
	flag.Parse()
	if *i {
		fmt.Print(info, "\n")
		os.Exit(0)
	}
	setup(*c)
	startup(*c)
}

// -----------------------------------------------------------------------------

func setup(c string) {
	if filepath.Ext(c) != conf.FileExtCONF {
		log.Printf("panic: system .conf file: %s: invalid extension\n", c)
		log.Fatalf("-----> valid file extension is '%s'\n", conf.FileExtCONF)
	}
	info, err := os.Stat(c)
	if err != nil {
		log.Println("warning: system .conf file:", err)
		return
	} else if info.IsDir() {
		log.Fatalf("panic: system .conf file: %s: not a file\n", c)
	}
	set, err := reader.ReadConf(c)
	if err != nil {
		log.Fatalln("panic: system .conf file:", err)
	}
	// configuration:
	conf.Path = filepath.Dir(c)
	session := strings.TrimSpace(
		strings.TrimSuffix(filepath.Base(c), conf.FileExtCONF))
	errors := conf.C.Fill(session, set)
	if len(errors) != 0 {
		for i := range errors {
			log.Println(errors[i])
		}
		// for a safe start:
		log.Fatalf("panic: system .conf file: %s: invalid file\n", c)
	}
	conf.C.Timestamp = info.ModTime().Unix()
}

func startup(c string) {
	logger.Init()
	logger.L.System.Println("start: session name:", conf.C.Session)
	go inspector.Launch(c)
	// handlers:
	http.Handle("/res/", http.StripPrefix("/res/",
		handler.FileServer(http.Dir(conf.PathResources), false)))
	http.Handle("/add/", http.StripPrefix("/add/",
		handler.FileServer(http.Dir(conf.C.Resources), true)))
	http.HandleFunc("/favicon.ico", handler.Favicon)
	http.HandleFunc("/", handler.Main)
	// server:
	const format = "panic: %s server: %v\n"
	switch conf.C.Protocol {
	case "https":
		go func() {
			if err := http.ListenAndServe(conf.C.Address,
				http.HandlerFunc(handler.RedirectToHTTPS)); err != nil {
				logger.L.System.Printf(format, "'http' slave", err)
				log.Fatalf(format, "'http' slave", err)
			}
		}()
		if err := http.ListenAndServeTLS(conf.C.AddressTLS,
			conf.C.CertFile, conf.C.KeyFile, nil); err != nil {
			logger.L.System.Printf(format, "'https' master", err)
			log.Fatalf(format, "'https' master", err)
		}
	default:
		if err := http.ListenAndServe(conf.C.Address, nil); err != nil {
			logger.L.System.Printf(format, "'http' master", err)
			log.Fatalf(format, "'http' master", err)
		}
	}
}