ran.go

package main

import "syscall"
import "os/signal"
import "net/http"
import "os"
import "fmt"
import "strings"
import "sync"
import "github.com/justmiles/ran/global"
import "github.com/justmiles/ran/server"

// version information
var _version_ = "unknown"
var _branch_ = "unknown"
var _commitId_ = "unknown"
var _buildTime_ = "unknown"

var versionInfo = fmt.Sprintf("Version: %s, Branch: %s, Build: %s, Build time: %s",
	_version_, _branch_, _commitId_, _buildTime_)

func catchSignal() {
	signal_channel := make(chan os.Signal, 1)
	signal.Notify(signal_channel, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
	go func() {
		for value := range signal_channel {
			global.Logger.Infof("System: Catch signal: %s, Ran is going to shutdown", value.String())
			global.Logger.Wait()
			os.Exit(0)
		}
	}()
}

// Get all Listening address, like: http://127.0.0.1:8080. The return value is used for recording logs.
func getListeningAddr() (addr []string, err error) {
	for _, ip := range global.Config.IP {
		if global.Config.TLS != nil {
			if global.Config.TLS.Policy == global.TLSOnly {
				addr = append(addr, fmt.Sprintf("https://%s:%d", ip, global.Config.TLS.Port))
			} else {
				addr = append(addr, fmt.Sprintf("http://%s:%d", ip, global.Config.Port))
				addr = append(addr, fmt.Sprintf("https://%s:%d", ip, global.Config.TLS.Port))
			}
		} else {
			addr = append(addr, fmt.Sprintf("http://%s:%d", ip, global.Config.Port))
		}
	}

	if len(addr) == 0 {
		err = fmt.Errorf("No IP address provided")
		return
	}

	return
}

func startLog() {
	msg := "System: Ran is running on "

	if global.Config.TLS != nil {
		switch global.Config.TLS.Policy {
		case global.TLSRedirect:
			msg += fmt.Sprintf("HTTPS port %d, all traffic from HTTP port %d will redirect to HTTPS port",
				global.Config.TLS.Port, global.Config.Port)

		case global.TLSBoth:
			msg += fmt.Sprintf("HTTP port %d and HTTPS port %d", global.Config.Port, global.Config.TLS.Port)

		case global.TLSOnly:
			msg += fmt.Sprintf("HTTPS port %d", global.Config.TLS.Port)
		}
	} else {
		msg += fmt.Sprintf("HTTP port %d", global.Config.Port)
	}

	if global.Config.Auth != nil {
		msg += fmt.Sprintf(" with %s auth", string(global.Config.Auth.Method))
	}

	global.Logger.Info(msg)

	addr, err := getListeningAddr()
	if err != nil {
		global.Logger.Error(err)
	} else {
		for _, i := range addr {
			global.Logger.Infof("System: Listening on %s", i)
		}
	}
}

func main() {
	global.LoadConfig(versionInfo)

	defer func() {
		global.Logger.Wait()
	}()

	if global.Config.ShowConf {
		for _, line := range strings.Split(global.Config.String(), "\n") {
			line = strings.TrimSpace(line)
			if line != "" {
				global.Logger.Infof("Config: %s", line)
			}
		}
	}

	catchSignal()

	var wg sync.WaitGroup
	defer wg.Wait()

	startLog()

	ran := server.NewRanServer(global.Config.Config, global.Logger)

	startHTTPServer := func() {
		for _, ip := range global.Config.IP {
			wg.Add(1)
			go func(ip string) {
				err := http.ListenAndServe(
					fmt.Sprintf("%s:%d", ip, global.Config.Port),
					ran.Serve(),
				)
				if err != nil {
					global.Logger.Fatal(err)
				}
				wg.Done()
			}(ip)
		}
	}

	startTLSServer := func() {
		for _, ip := range global.Config.IP {
			wg.Add(1)
			go func(ip string) {
				err := http.ListenAndServeTLS(
					fmt.Sprintf("%s:%d", ip, global.Config.TLS.Port),
					global.Config.TLS.PublicKey,
					global.Config.TLS.PrivateKey,
					ran.Serve(),
				)
				if err != nil {
					global.Logger.Fatal(err)
				}
				wg.Done()
			}(ip)
		}
	}

	redirectToHTTPS := func() {
		for _, ip := range global.Config.IP {
			wg.Add(1)
			go func(ip string) {
				err := http.ListenAndServe(
					fmt.Sprintf("%s:%d", ip, global.Config.Port),
					ran.RedirectToHTTPS(global.Config.TLS.Port),
				)
				if err != nil {
					global.Logger.Fatal(err)
				}
				wg.Done()
			}(ip)
		}
	}

	if global.Config.TLS != nil {
		// turn on TLS encryption

		startTLSServer()

		if global.Config.TLS.Policy == global.TLSRedirect {
			redirectToHTTPS()
		} else if global.Config.TLS.Policy == global.TLSBoth {
			startHTTPServer()
		}
	} else {
		startHTTPServer()
	}

}