golang-fave/main.go

package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"net/http"
	"os"
	"time"

	"golang-fave/assets"
	"golang-fave/cblocks"
	"golang-fave/consts"
	"golang-fave/domains"
	"golang-fave/engine"
	"golang-fave/engine/basket"
	"golang-fave/engine/mysqlpool"
	"golang-fave/logger"
	"golang-fave/modules"
	"golang-fave/support"
	"golang-fave/utils"

	"github.com/vladimirok5959/golang-server-bootstrap/bootstrap"
	"github.com/vladimirok5959/golang-server-resources/resource"
	"github.com/vladimirok5959/golang-server-sessions/session"
	"github.com/vladimirok5959/golang-server-static/static"
)

func init() {
	flag.StringVar(&consts.ParamHost, "host", "0.0.0.0", "server host")
	flag.IntVar(&consts.ParamPort, "port", 8080, "server port")
	flag.StringVar(&consts.ParamWwwDir, "dir", "", "virtual hosts directory")
	flag.BoolVar(&consts.ParamDebug, "debug", false, "debug mode with ignoring log files")
	flag.BoolVar(&consts.ParamKeepAlive, "keepalive", false, "enable/disable server keep alive")
	flag.Parse()
}

func main() {
	// Universal, params by env vars
	if consts.ParamHost == "0.0.0.0" {
		if os.Getenv("FAVE_HOST") != "" {
			consts.ParamHost = os.Getenv("FAVE_HOST")
		}
	}
	if consts.ParamPort == 8080 {
		if os.Getenv("FAVE_PORT") != "" {
			consts.ParamPort = utils.StrToInt(os.Getenv("FAVE_PORT"))
		}
	}
	if consts.ParamWwwDir == "" {
		if os.Getenv("FAVE_DIR") != "" {
			consts.ParamWwwDir = os.Getenv("FAVE_DIR")
		}
	}
	if consts.ParamDebug == false {
		if os.Getenv("FAVE_DEBUG") == "true" {
			consts.ParamDebug = true
		}
	}
	if consts.ParamKeepAlive == false {
		if os.Getenv("FAVE_KEEPALIVE") == "true" {
			consts.ParamKeepAlive = true
		}
	}

	// Check www dir
	consts.ParamWwwDir = utils.FixPath(consts.ParamWwwDir)
	if !utils.IsDirExists(consts.ParamWwwDir) {
		fmt.Printf("Virtual hosts directory is not exists\n")
		fmt.Printf("Example: ./fave -host 127.0.0.1 -port 80 -dir ./hosts\n")
		return
	}

	// Run database migration
	if err := support.New().Migration(consts.ParamWwwDir); err != nil {
		fmt.Printf("[ERROR] MIGRATION FAILED: %s\n", err)
	}

	// Init logger
	lg := logger.New()
	defer lg.Close()

	// Attach www dir to logger
	lg.SetWwwDir(consts.ParamWwwDir)

	// Session cleaner
	sess_cl_ch, sess_cl_stop := session_clean_start(consts.ParamWwwDir)
	defer session_clean_stop(sess_cl_ch, sess_cl_stop)

	// Image processing
	imgs_cl_ch, imgs_cl_stop := image_start(consts.ParamWwwDir)
	defer image_stop(imgs_cl_ch, imgs_cl_stop)

	// Init mounted resources
	res := resource.New()
	assets.PopulateResources(res)

	// Init static files helper
	stat := static.New(consts.DirIndexFile)

	// Init modules
	mods := modules.New()

	// MySQL connections pool
	mpool := mysqlpool.New()

	// Xml generation
	xml_cl_ch, xml_cl_stop := xml_start(consts.ParamWwwDir, mpool)
	defer xml_stop(xml_cl_ch, xml_cl_stop)

	// SMTP sender
	smtp_cl_ch, smtp_cl_stop := smtp_start(consts.ParamWwwDir, mpool)
	defer smtp_stop(smtp_cl_ch, smtp_cl_stop)

	// Shop basket
	sb := basket.New()
	sb_cl_ch, sb_cl_stop := basket_clean_start(sb)
	defer basket_clean_stop(sb_cl_ch, sb_cl_stop)

	// Init cache blocks
	cbs := cblocks.New()

	// Init and start web server
	server_address := fmt.Sprintf("%s:%d", consts.ParamHost, consts.ParamPort)

	bootstrap.Start(
		&bootstrap.Opts{
			Timeout: 8 * time.Second,
			Handle:  lg.Handler,
			Host:    server_address,
			Path:    consts.AssetsPath,
			Object:  mpool,
			Cbserv: func(s *http.Server) {
				s.SetKeepAlivesEnabled(consts.ParamKeepAlive)
			},
			Before: func(ctx context.Context, w http.ResponseWriter, r *http.Request, o interface{}) {
				w.Header().Set("Server", "fave.pro/"+consts.ServerVersion)
			},
			After: func(ctx context.Context, w http.ResponseWriter, r *http.Request, o interface{}) {
				// Schema
				r.URL.Scheme = "http"

				// Mounted assets
				if res.Response(w, r, func(w http.ResponseWriter, r *http.Request, i *resource.OneResource) {
					w.Header().Set("Cache-Control", "public, max-age=31536000")
					if consts.ParamDebug && i.Path == "assets/cp/scripts.js" {
						w.Write([]byte("window.fave_debug=true;"))
					}
				}, nil) {
					return
				}

				// Host and port
				host, port := utils.ExtractHostPort(r.Host, false)
				curr_host := host

				// Domain bindings
				doms := domains.New(consts.ParamWwwDir)
				if mhost := doms.GetHost(host); mhost != "" {
					curr_host = mhost
				}

				vhost_dir := consts.ParamWwwDir + string(os.PathSeparator) + curr_host
				if !utils.IsDirExists(vhost_dir) {
					curr_host = "localhost"
					vhost_dir = consts.ParamWwwDir + string(os.PathSeparator) + "localhost"
				}

				// Check for minimal dir structure
				vhost_dir_config := vhost_dir + string(os.PathSeparator) + "config"
				vhost_dir_htdocs := vhost_dir + string(os.PathSeparator) + "htdocs"
				vhost_dir_logs := vhost_dir + string(os.PathSeparator) + "logs"
				vhost_dir_template := vhost_dir + string(os.PathSeparator) + "template"
				vhost_dir_tmp := vhost_dir + string(os.PathSeparator) + "tmp"
				if !utils.IsDirExists(vhost_dir_config) {
					utils.SystemErrorPageEngine(w, errors.New("Folder "+vhost_dir_config+" is not found"))
					return
				}
				if !utils.IsDirExists(vhost_dir_htdocs) {
					utils.SystemErrorPageEngine(w, errors.New("Folder "+vhost_dir_htdocs+" is not found"))
					return
				}
				if !utils.IsDirExists(vhost_dir_logs) {
					utils.SystemErrorPageEngine(w, errors.New("Folder "+vhost_dir_logs+" is not found"))
					return
				}
				if !utils.IsDirExists(vhost_dir_template) {
					utils.SystemErrorPageEngine(w, errors.New("Folder "+vhost_dir_template+" is not found"))
					return
				}
				if !utils.IsDirExists(vhost_dir_tmp) {
					utils.SystemErrorPageEngine(w, errors.New("Folder "+vhost_dir_tmp+" is not found"))
					return
				}

				// Static files
				if stat.Response(vhost_dir_htdocs, w, r, nil, nil) {
					return
				}

				// Robots.txt and styles.css from template dir
				if ServeTemplateFile(w, r, "robots.txt", "", vhost_dir_template) {
					return
				}
				if ServeTemplateFile(w, r, "styles.css", "assets/theme/", vhost_dir_template) {
					return
				}
				if ServeTemplateFile(w, r, "scripts.js", "assets/theme/", vhost_dir_template) {
					return
				}

				// Session
				sess := session.New(w, r, vhost_dir_tmp)
				defer sess.Close()

				// Convert
				var mp *mysqlpool.MySqlPool
				if mpool, ok := o.(*mysqlpool.MySqlPool); ok {
					mp = mpool
				}

				// Logic
				if mp != nil {
					if engine.Response(
						mp,
						sb,
						lg,
						mods,
						w,
						r,
						sess,
						cbs,
						host,
						port,
						curr_host,
						vhost_dir_config,
						vhost_dir_htdocs,
						vhost_dir_logs,
						vhost_dir_template,
						vhost_dir_tmp,
					) {
						return
					}
				}

				// Error 404
				utils.SystemErrorPage404(w)
			},
		},
	)

	// Close MySQL
	mpool.CloseAll()
}

func ServeTemplateFile(w http.ResponseWriter, r *http.Request, file string, path string, dir string) bool {
	if r.URL.Path == "/"+path+file {
		f, err := os.Open(dir + string(os.PathSeparator) + file)
		if err == nil {
			defer f.Close()
			st, err := os.Stat(dir + string(os.PathSeparator) + file)
			if err == nil {
				if !st.Mode().IsDir() {
					http.ServeFile(w, r, dir+string(os.PathSeparator)+file)
					return true
				}
			}
		}
	}
	return false
}