Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

9.6 KB
Raw Blame
package env

import (
	"fmt"
	"net/url"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"time"

	"path"

	"github.com/getfider/fider/app/pkg/errors"
	"github.com/joeshaw/envdecode"
)

var (
	// these values are set by the CI build
	commithash = ""
	version    = ""
)

func Version() string {
	v := version
	if v == "" {
		v = "dev"
	}

	if commithash == "" {
		return v
	}

	return fmt.Sprintf("%s-%s", v, commithash)
}

type config struct {
	Environment    string `env:"GO_ENV,default=production"`
	SignUpDisabled bool   `env:"SIGNUP_DISABLED,default=false"`
	TLS            struct {
		Automatic      bool   `env:"SSL_AUTO,default=false"`
		Certificate    string `env:"SSL_CERT"`
		CertificateKey string `env:"SSL_CERT_KEY"`
	}
	HTTP struct {
		ReadTimeout  time.Duration `env:"HTTP_READ_TIMEOUT,default=5s,strict"`
		WriteTimeout time.Duration `env:"HTTP_WRITE_TIMEOUT,default=10s,strict"`
		IdleTimeout  time.Duration `env:"HTTP_IDLE_TIMEOUT,default=120s,strict"`
		// Largest accepted request body in bytes. The biggest legitimate request is a post edit
		// carrying 3 attachments of 5 MiB each, which is ~20 MiB once base64-encoded in JSON.
		MaxBodySize int64 `env:"HTTP_MAX_BODY_SIZE,default=26214400,strict"`
	}
	Port                        string `env:"PORT,default=3000"`
	Host                        string `env:"HOST,default="`
	HostMode                    string `env:"HOST_MODE,default=single"`
	HostDomain                  string `env:"HOST_DOMAIN"`
	BaseURL                     string `env:"BASE_URL"`
	Locale                      string `env:"LOCALE,default=en"`
	JWTSecret                   string `env:"JWT_SECRET,required"`
	PostCreationWithTagsEnabled bool   `env:"POST_CREATION_WITH_TAGS_ENABLED,default=false"`
	AllowAllowedSchemes         bool   `env:"ALLOW_ALLOWED_SCHEMES,default=true"`
	AllowPrivateNetworkTargets  bool   `env:"ALLOW_PRIVATE_NETWORK_TARGETS,default=false"`
	Stripe                      struct {
		SecretKey      string `env:"STRIPE_SECRET_KEY"`
		WebhookSecret  string `env:"STRIPE_WEBHOOK_SECRET"`
		PriceID        string `env:"STRIPE_PRICE_ID"`
		AnnualPriceID  string `env:"STRIPE_ANNUAL_PRICE_ID"`
		UKVATTaxRateID string `env:"STRIPE_UK_VAT_TAX_RATE_ID"`
	}
	Metrics struct {
		Enabled bool   `env:"METRICS_ENABLED,default=false"`
		Port    string `env:"METRICS_PORT,default=4000"`
		Host    string `env:"METRICS_HOST,default="`
	}
	Database struct {
		URL          string `env:"DATABASE_URL,required"`
		MaxIdleConns int    `env:"DATABASE_MAX_IDLE_CONNS,default=2,strict"`
		MaxOpenConns int    `env:"DATABASE_MAX_OPEN_CONNS,default=4,strict"`
	}
	CDN struct {
		Host string `env:"CDN_HOST"`
	}
	UserList struct {
		Enabled bool   `env:"USER_LIST_ENABLED,default=false"`
		ApiKey  string `env:"USER_LIST_APIKEY"`
	}
	Log struct {
		Level      string `env:"LOG_LEVEL,default=INFO"`
		Structured bool   `env:"LOG_STRUCTURED,default=false"`
		Console    bool   `env:"LOG_CONSOLE,default=true"`
		Sql        bool   `env:"LOG_SQL,default=false"`
		File       bool   `env:"LOG_FILE,default=false"`
		OutputFile string `env:"LOG_FILE_OUTPUT,default=logs/output.log"`
	}
	OAuth struct {
		Google struct {
			ClientID string `env:"OAUTH_GOOGLE_CLIENTID"`
			Secret   string `env:"OAUTH_GOOGLE_SECRET"`
		}
		Facebook struct {
			AppID  string `env:"OAUTH_FACEBOOK_APPID"`
			Secret string `env:"OAUTH_FACEBOOK_SECRET"`
		}
		GitHub struct {
			ClientID string `env:"OAUTH_GITHUB_CLIENTID"`
			Secret   string `env:"OAUTH_GITHUB_SECRET"`
		}
	}
	Email struct {
		Type      string `env:"EMAIL"` // possible values: smtp, mailgun, awsses
		NoReply   string `env:"EMAIL_NOREPLY,required"`
		Allowlist string `env:"EMAIL_ALLOWLIST"`
		Blocklist string `env:"EMAIL_BLOCKLIST"`
		AWSSES    struct {
			Region          string `env:"EMAIL_AWSSES_REGION"`
			AccessKeyID     string `env:"EMAIL_AWSSES_ACCESS_KEY_ID"`
			SecretAccessKey string `env:"EMAIL_AWSSES_SECRET_ACCESS_KEY"`
		}
		Mailgun struct {
			APIKey string `env:"EMAIL_MAILGUN_API"`
			Domain string `env:"EMAIL_MAILGUN_DOMAIN"`
			Region string `env:"EMAIL_MAILGUN_REGION,default=US"` // possible values: US or EU
		}
		SMTP struct {
			Host              string `env:"EMAIL_SMTP_HOST"`
			Port              string `env:"EMAIL_SMTP_PORT"`
			Username          string `env:"EMAIL_SMTP_USERNAME"`
			Password          string `env:"EMAIL_SMTP_PASSWORD"`
			EnableStartTLS    bool   `env:"EMAIL_SMTP_ENABLE_STARTTLS,default=true"`
			EnableImplicitTLS bool   `env:"EMAIL_SMTP_ENABLE_IMPLICIT_TLS,default=false"`
		}
	}
	BlobStorage struct {
		Type string `env:"BLOB_STORAGE,default=sql"` // possible values: sql, fs or s3
		S3   struct {
			EndpointURL     string `env:"BLOB_STORAGE_S3_ENDPOINT_URL"`
			Region          string `env:"BLOB_STORAGE_S3_REGION"`
			AccessKeyID     string `env:"BLOB_STORAGE_S3_ACCESS_KEY_ID"`
			SecretAccessKey string `env:"BLOB_STORAGE_S3_SECRET_ACCESS_KEY"`
			BucketName      string `env:"BLOB_STORAGE_S3_BUCKET"`
		}
		FS struct {
			Path string `env:"BLOB_STORAGE_FS_PATH"`
		}
	}
	Maintenance struct {
		Enabled bool   `env:"MAINTENANCE,default=false,strict"`
		Message string `env:"MAINTENANCE_MESSAGE"`
		Until   string `env:"MAINTENANCE_UNTIL"`
	}
	Webhook struct {
		DisableOnFailure bool `env:"WEBHOOK_DISABLE_ON_FAILURE,default=true"`
	}
	GoogleAnalytics  string `env:"GOOGLE_ANALYTICS"`
	SearchNoiseWords string `env:"SEARCH_NOISE_WORDS,default=add|support|for|implement|create|make|allow|enable|provide|some|also|include|very|make|and|for|to|a|able|function|feature|app"`
}

// Config is a strongly typed reference to all configuration parsed from Environment Variables
var Config config

func init() {
	Reload()
}

// Reload configuration from current Enviornment Variables
func Reload() {
	Config = config{}
	err := envdecode.Decode(&Config)
	if err != nil {
		panic(errors.Wrap(err, "failed to parse environment variables"))
	}

	Config.GoogleAnalytics = strings.TrimSpace(Config.GoogleAnalytics)

	if IsSingleHostMode() {
		if Config.HostDomain != "" {
			panic("HOST_DOMAIN environment variable has been replaced by BASE_URL. Set it to your site base url, e.g: https://feedback.mysite.com")
		}

		mustBeSet("BASE_URL")

		_, err := url.Parse(Config.BaseURL)
		if err != nil {
			panic(errors.Wrap(err, "'%s' is not a valid URL", Config.BaseURL))
		}
	}

	// Email Type can be inferred if absense
	if Config.Email.Type == "" {
		if Config.Email.Mailgun.APIKey != "" {
			Config.Email.Type = "mailgun"
		} else if Config.Email.AWSSES.AccessKeyID != "" {
			Config.Email.Type = "awsses"
		} else {
			Config.Email.Type = "smtp"
		}
	}

	switch Config.Email.Type {
	case "mailgun":
		mustBeSet("EMAIL_MAILGUN_API")
		mustBeSet("EMAIL_MAILGUN_DOMAIN")
	case "awsses":
		mustBeSet("EMAIL_AWSSES_REGION")
		mustBeSet("EMAIL_AWSSES_ACCESS_KEY_ID")
		mustBeSet("EMAIL_AWSSES_SECRET_ACCESS_KEY")
	case "smtp":
		mustBeSet("EMAIL_SMTP_HOST")
		mustBeSet("EMAIL_SMTP_PORT")
	}

	switch Config.BlobStorage.Type {
	case "s3":
		mustBeSet("BLOB_STORAGE_S3_BUCKET")
	case "fs":
		mustBeSet("BLOB_STORAGE_FS_PATH")
	}
}

func mustBeSet(name string) {
	value := os.Getenv(name)
	if value == "" {
		panic(fmt.Errorf("could not find environment variable named '%s'", name))
	}
}

// IsSingleHostMode returns true if host mode is set to single tenant
func IsSingleHostMode() bool {
	return Config.HostMode == "single"
}

var hasLegal *bool

// HasLegal returns true if current instance contains legal documents: privacy.md and terms.md
func HasLegal() bool {
	if hasLegal == nil {
		_, err1 := os.Stat(Etc("privacy.md"))
		_, err2 := os.Stat(Etc("terms.md"))
		exists := err1 == nil && err2 == nil
		hasLegal = &exists
	}
	return *hasLegal
}

// MultiTenantDomain returns domain name of current instance for multi tenant hosts
func MultiTenantDomain() string {
	if !IsSingleHostMode() {
		return "." + Config.HostDomain
	}
	return ""
}

// IsBillingEnabled returns true if Stripe is configured and running in multi-tenant mode
// Billing is only available in multi-tenant hosted mode, not in single-host self-hosted mode
func IsBillingEnabled() bool {
	return IsMultiHostMode() && Config.Stripe.SecretKey != ""
}

// IsMultiHostMode returns true if host mode is set to multi tenant
func IsMultiHostMode() bool {
	return Config.HostMode == "multi"
}

// IsProduction returns true on Fider production environment
func IsProduction() bool {
	return Config.Environment == "production" || (!IsTest() && !IsDevelopment())
}

// SearchNoiseWords returns a list of words that should be ignored on search
func SearchNoiseWords() []string {
	return strings.Split(Config.SearchNoiseWords, "|")
}

// IsTest returns true on Fider test environment
func IsTest() bool {
	return Config.Environment == "test"
}

// IsDevelopment returns true on Fider production environment
func IsDevelopment() bool {
	return Config.Environment == "development"
}

// Path returns root path of project + given path
func Path(p ...string) string {
	root := "./"
	if IsTest() {
		_, b, _, _ := runtime.Caller(0)
		basepath := filepath.Dir(b)
		root = path.Join(basepath, "../../../")
	}

	elems := append([]string{root}, p...)
	return path.Join(elems...)
}

// Etc returns a path to a folder or file inside the /etc/ folder
func Etc(p ...string) string {
	paths := append([]string{"etc"}, p...)
	return Path(paths...)
}

// Subdomain returns the Fider subdomain (if available) from given host
func Subdomain(host string) string {
	if IsSingleHostMode() {
		return ""
	}

	domain := MultiTenantDomain()
	if domain != "" && strings.Contains(host, domain) {
		return strings.ReplaceAll(host, domain, "")
	}

	if Config.CDN.Host != "" {
		domain = Config.CDN.Host
		parts := strings.Split(domain, ":")
		if parts[0] != "" && strings.Contains(host, "."+parts[0]) {
			return strings.ReplaceAll(host, "."+parts[0], "")
		}
	}

	return ""
}