path: root/setting/setting.go

package setting

import (
	"github.com/Unknwon/com"
	"github.com/go-macaron/session"
	"github.com/gogap/logrus_mate"
	// Logrus to file
	_ "github.com/gogap/logrus_mate/hooks/file"
	// Logrus to syslog [optional]
	_ "github.com/gogap/logrus_mate/hooks/syslog"
	logrusFname "github.com/onrik/logrus/filename"
	log "github.com/sirupsen/logrus"
	"gopkg.in/ini.v1"
	"net/mail"
	"net/url"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
)

// Scheme of type HTTP, HTTPS, etc.
type Scheme string

// Scheme consts
const (
	SchemeHTTP       Scheme = "http"
	SchemeHTTPS      Scheme = "https"
	SchemeFcgi       Scheme = "fcgi"
	SchemeUnixSocket Scheme = "unix"
)

// blah
var (
	// Build infos added by -ldflags
	BuildTime    string
	BuildGitHash string

	UseRaven bool

	// App Settings
	AppVer         string
	AppPath        string
	AppName        string
	AppURL         string
	AppSubURL      string
	AppSubURLDepth int // Number of slashes
	CanRegister    bool
	ProdMode       bool
	NeedsImpressum bool

	// Cron tasks
	Cron struct {
	}

	// Worker configuration
	Worker struct {
		RedisHost string
		RedisDb   string
		RedisPort string
	}

	// Storage configuration
	Storage struct {
		Path string
	}

	AudiowaveformBin string

	// Server settings
	Protocol             Scheme
	UnixSocketPermission uint32
	Domain               string
	HTTPAddr             string
	HTTPPort             string
	DisableRouterLog     bool
	StaticRootPath       string

	HTTP struct {
		AccessControlAllowOrigin string
	}

	// Database Settings
	UseSQLite3    bool
	UseMySQL      bool
	UsePostgreSQL bool
	UseMSSQL      bool

	// Global setting objects
	CustomConf    string
	IsWindows     bool
	Cfg           *ini.File
	HasRobotsTxt  bool
	RobotsTxtPath string

	// Session settings
	SessionConfig  session.Options
	CSRFCookieName string

	// Security settings
	InstallLock             bool
	SecretKey               string
	LoginRememberDays       int
	CookieUserName          string
	CookieRememberName      string
	CookieSecure            bool
	EnableLoginStatusCookie bool
	LoginStatusCookieName   string

	// Cache settings
	CacheAdapter  string
	CacheInterval int
	CacheConn     string

	// i18n settings
	Langs     []string
	Names     []string
	dateLangs map[string]string

	// Markdown sttings
	Markdown struct {
		EnableHardLineBreak bool
		CustomURLSchemes    []string `ini:"CUSTOM_URL_SCHEMES"`
		FileExtensions      []string
	}

	// Smartypants settings
	Smartypants struct {
		Enabled      bool
		Fractions    bool
		Dashes       bool
		LatexDashes  bool
		AngledQuotes bool
	}

	// Bloby manages Static settings
	Bloby struct {
		MaxSizeDisplay int64
		MaxPageDisplay int64
		MaxRawSize     int64
	}

	// Log settings
	LoggerBdd *log.Logger
)

// DateLang transforms standard language locale name to corresponding value in datetime plugin.
func DateLang(lang string) string {
	name, ok := dateLangs[lang]
	if ok {
		return name
	}
	return "en"
}

// execPath returns the executable path.
func execPath() (string, error) {
	file, err := exec.LookPath(os.Args[0])
	if err != nil {
		return "", err
	}
	return filepath.Abs(file)
}

func init() {
	IsWindows = runtime.GOOS == "windows"

	var err error
	if AppPath, err = execPath(); err != nil {
		log.Fatalf("Fail to get app path: %v\n", err)
	}

	// Note: we don't use path.Dir here because it does not handle case
	//	which path starts with two "/" in Windows: "//psf/Home/..."
	AppPath = strings.Replace(AppPath, "\\", "/", -1)
}

func forcePathSeparator(path string) {
	if strings.Contains(path, "\\") {
		log.Fatalf("Do not use '\\' or '\\\\' in paths, instead, please use '/' in all places")
	}
}

// InitConfig to init config from ini file
func InitConfig() {
	workDir, err := WorkDir()
	if err != nil {
		log.Fatalf("Fail to get work directory: %v", err)
	}

	if len(CustomConf) == 0 {
		CustomConf = workDir + "/conf/app.ini"
	}

	initLogging(workDir)

	Cfg, err = ini.Load(CustomConf)
	if err != nil {
		log.Fatalf("Fail to parse '%s': %v", CustomConf, err)
	}
	Cfg.NameMapper = ini.AllCapsUnderscore
	Cfg.BlockMode = false // We don't write anything, speedup cfg reading

	homeDir, err := com.HomeDir()
	if err != nil {
		log.Fatalf("Fail to get home directory: %v", err)
	}
	homeDir = strings.Replace(homeDir, "\\", "/", -1)

	sec := Cfg.Section("server")
	AppName = Cfg.Section("").Key("APP_NAME").MustString("reel2bits")
	AppURL = sec.Key("ROOT_URL").MustString("http://localhost:4000/")
	if AppURL[len(AppURL)-1] != '/' {
		AppURL += "/"
	}

	NeedsImpressum = Cfg.Section("").Key("NEEDS_IMPRESSUM").MustBool(false)

	// Check if has app suburl.
	appURL, err := url.Parse(AppURL)
	if err != nil {
		log.Fatalf("Invalid ROOT_URL '%s': %s", AppURL, err)
	}
	// Suburl should start with '/' and end without '/', such as '/{subpath}'.
	// This value is empty if site does not have sub-url.
	AppSubURL = strings.TrimSuffix(appURL.Path, "/")
	AppSubURLDepth = strings.Count(AppSubURL, "/")

	CanRegister = Cfg.Section("").Key("CAN_REGISTER").MustBool(true)

	Protocol = SchemeHTTP
	if sec.Key("PROTOCOL").String() == "https" {
		Protocol = SchemeHTTPS
		log.Warn("https not supported")
	} else if sec.Key("PROTOCOL").String() == "fcgi" {
		Protocol = SchemeFcgi
		log.Warn("fcgi not supported")
	} else if sec.Key("PROTOCOL").String() == "unix" {
		Protocol = SchemeUnixSocket
		log.Warn("socket not supported")
		UnixSocketPermissionRaw := sec.Key("UNIX_SOCKET_PERMISSION").MustString("666")
		UnixSocketPermissionParsed, err := strconv.ParseUint(UnixSocketPermissionRaw, 8, 32)
		if err != nil || UnixSocketPermissionParsed > 0777 {
			log.Fatalf("Fail to parse unixSocketPermission: %s", UnixSocketPermissionRaw)
		}
		UnixSocketPermission = uint32(UnixSocketPermissionParsed)
	}
	Domain = sec.Key("DOMAIN").MustString("localhost")
	HTTPAddr = sec.Key("HTTP_ADDR").MustString("0.0.0.0")
	HTTPPort = sec.Key("HTTP_PORT").MustString("3000")
	DisableRouterLog = sec.Key("DISABLE_ROUTER_LOG").MustBool()
	StaticRootPath = sec.Key("STATIC_ROOT_PATH").MustString(workDir)

	sec = Cfg.Section("security")
	SecretKey = sec.Key("SECRET_KEY").String()

	sec = Cfg.Section("storage")
	Storage.Path = sec.Key("PATH").MustString(path.Join(workDir, "/uploads"))

	sec = Cfg.Section("audio")
	AudiowaveformBin = sec.Key("AUDIOWAVEFORM_BIN").MustString("/usr/bin/audiowaveform")

	HasRobotsTxt = com.IsFile(path.Join