codebydante's picture
Upload 114 files
bd894b3 verified
Raw History Blame Contribute Delete
10.2 kB
package config
import (
"errors"
"io"
"net"
"net/http"
"os"
"path/filepath"
"reflect"
"regexp"
"strconv"
"strings"
"github.com/joho/godotenv"
"github.com/kelseyhightower/envconfig"
"github.com/spf13/cobra"
"go.uber.org/zap"
)
var ValueOf = &config{}
type allowedUsers []int64
func (au *allowedUsers) Decode(value string) error {
if value == "" {
return nil
}
ids := strings.Split(string(value), ",")
for _, id := range ids {
idInt, err := strconv.ParseInt(id, 10, 64)
if err != nil {
return err
}
*au = append(*au, idInt)
}
return nil
}
type config struct {
ApiID int32 `envconfig:"API_ID" required:"true"`
ApiHash string `envconfig:"API_HASH" required:"true"`
BotToken string `envconfig:"BOT_TOKEN" required:"true"`
LogChannelID int64 `envconfig:"LOG_CHANNEL" required:"true"`
Dev bool `envconfig:"DEV" default:"false"`
Port int `envconfig:"PORT" default:"8080"`
Host string `envconfig:"HOST" default:""`
HashLength int `envconfig:"HASH_LENGTH" default:"6"`
UseSessionFile bool `envconfig:"USE_SESSION_FILE" default:"true"`
UserSession string `envconfig:"USER_SESSION"`
UsePublicIP bool `envconfig:"USE_PUBLIC_IP" default:"false"`
AllowedUsers allowedUsers `envconfig:"ALLOWED_USERS"`
MultiTokens []string
FirebaseJSON string `envconfig:"FIREBASE_JSON"`
// stream specific config
StreamConcurrency int `envconfig:"STREAM_CONCURRENCY" default:"8"`
StreamBufferCount int `envconfig:"STREAM_BUFFER_COUNT" default:"16"`
StreamTimeoutSec int `envconfig:"STREAM_TIMEOUT_SEC" default:"30"`
StreamMaxRetries int `envconfig:"STREAM_MAX_RETRIES" default:"10"`
}
var botTokenRegex = regexp.MustCompile(`MULTI\_TOKEN\d+=(.*)`)
func (c *config) loadFromEnvFile(log *zap.Logger) {
envPath := filepath.Clean("fsb.env")
log.Sugar().Infof("Trying to load ENV vars from %s", envPath)
err := godotenv.Load(envPath)
if err != nil {
if os.IsNotExist(err) {
log.Sugar().Errorf("ENV file not found: %s", envPath)
log.Sugar().Info("Please create fsb.env file")
log.Sugar().Info("For more info, refer: https://github.com/EverythingSuckz/TG-FileStreamBot/tree/golang#setting-up-things")
log.Sugar().Info("Please ignore this message if you are hosting it in a service like Heroku or other alternatives.")
} else {
log.Fatal("Unknown error while parsing env file.", zap.Error(err))
}
}
}
func SetFlagsFromConfig(cmd *cobra.Command) {
cmd.Flags().Int32("api-id", ValueOf.ApiID, "Telegram API ID")
cmd.Flags().String("api-hash", ValueOf.ApiHash, "Telegram API Hash")
cmd.Flags().String("bot-token", ValueOf.BotToken, "Telegram Bot Token")
cmd.Flags().Int64("log-channel", ValueOf.LogChannelID, "Telegram Log Channel ID")
cmd.Flags().Bool("dev", ValueOf.Dev, "Enable development mode")
cmd.Flags().IntP("port", "p", ValueOf.Port, "Server port")
cmd.Flags().String("host", ValueOf.Host, "Server host that will be included in links")
cmd.Flags().Int("hash-length", ValueOf.HashLength, "Hash length in links")
cmd.Flags().Bool("use-session-file", ValueOf.UseSessionFile, "Use session files")
cmd.Flags().String("user-session", ValueOf.UserSession, "Pyrogram user session")
cmd.Flags().Bool("use-public-ip", ValueOf.UsePublicIP, "Use public IP instead of local IP")
cmd.Flags().String("multi-token-txt-file", "", "Multi token txt file (Not implemented)")
cmd.Flags().Int("stream-concurrency", ValueOf.StreamConcurrency, "Number of parallel block fetches")
cmd.Flags().Int("stream-buffer-count", ValueOf.StreamBufferCount, "Number of blocks to prefetch")
cmd.Flags().Int("stream-timeout-sec", ValueOf.StreamTimeoutSec, "Maximum time to wait for a single block (in seconds)")
cmd.Flags().Int("stream-max-retries", ValueOf.StreamMaxRetries, "Number of retry attempts for failed fetches")
}
func (c *config) loadConfigFromArgs(log *zap.Logger, cmd *cobra.Command) {
apiID, _ := cmd.Flags().GetInt32("api-id")
if apiID != 0 {
os.Setenv("API_ID", strconv.Itoa(int(apiID)))
}
apiHash, _ := cmd.Flags().GetString("api-hash")
if apiHash != "" {
os.Setenv("API_HASH", apiHash)
}
botToken, _ := cmd.Flags().GetString("bot-token")
if botToken != "" {
os.Setenv("BOT_TOKEN", botToken)
}
logChannelID, _ := cmd.Flags().GetString("log-channel")
if logChannelID != "" {
os.Setenv("LOG_CHANNEL", logChannelID)
}
dev, _ := cmd.Flags().GetBool("dev")
if dev {
os.Setenv("DEV", strconv.FormatBool(dev))
}
port, _ := cmd.Flags().GetInt("port")
if port != 0 {
os.Setenv("PORT", strconv.Itoa(port))
}
host, _ := cmd.Flags().GetString("host")
if host != "" {
os.Setenv("HOST", host)
}
hashLength, _ := cmd.Flags().GetInt("hash-length")
if hashLength != 0 {
os.Setenv("HASH_LENGTH", strconv.Itoa(hashLength))
}
useSessionFile, _ := cmd.Flags().GetBool("use-session-file")
if useSessionFile {
os.Setenv("USE_SESSION_FILE", strconv.FormatBool(useSessionFile))
}
userSession, _ := cmd.Flags().GetString("user-session")
if userSession != "" {
os.Setenv("USER_SESSION", userSession)
}
usePublicIP, _ := cmd.Flags().GetBool("use-public-ip")
if usePublicIP {
os.Setenv("USE_PUBLIC_IP", strconv.FormatBool(usePublicIP))
}
multiTokens, _ := cmd.Flags().GetString("multi-token-txt-file")
if multiTokens != "" {
os.Setenv("MULTI_TOKEN_TXT_FILE", multiTokens)
// TODO: Add support for importing tokens from a separate file
}
streamConcurrency, _ := cmd.Flags().GetInt("stream-concurrency")
if streamConcurrency != 0 {
os.Setenv("STREAM_CONCURRENCY", strconv.Itoa(streamConcurrency))
}
streamBufferCount, _ := cmd.Flags().GetInt("stream-buffer-count")
if streamBufferCount != 0 {
os.Setenv("STREAM_BUFFER_COUNT", strconv.Itoa(streamBufferCount))
}
streamTimeoutSec, _ := cmd.Flags().GetInt("stream-timeout-sec")
if streamTimeoutSec != 0 {
os.Setenv("STREAM_TIMEOUT_SEC", strconv.Itoa(streamTimeoutSec))
}
streamMaxRetries, _ := cmd.Flags().GetInt("stream-max-retries")
if streamMaxRetries != 0 {
os.Setenv("STREAM_MAX_RETRIES", strconv.Itoa(streamMaxRetries))
}
}
func (c *config) setupEnvVars(log *zap.Logger, cmd *cobra.Command) {
c.loadFromEnvFile(log)
c.loadConfigFromArgs(log, cmd)
err := envconfig.Process("", c)
if err != nil {
log.Fatal("Error while parsing env variables", zap.Error(err))
}
var ipBlocked bool
ip, err := getIP(c.UsePublicIP)
if err != nil {
log.Error("Error while getting IP", zap.Error(err))
ipBlocked = true
}
if c.Host == "" {
c.Host = "http://" + ip + ":" + strconv.Itoa(c.Port)
if c.UsePublicIP {
if ipBlocked {
log.Sugar().Warn("Can't get public IP, using local IP")
} else {
log.Sugar().Warn("You are using a public IP, please be aware of the security risks while exposing your IP to the internet.")
log.Sugar().Warn("Use 'HOST' variable to set a domain name")
}
}
log.Sugar().Info("HOST not set, automatically set to " + c.Host)
}
val := reflect.ValueOf(c).Elem()
for _, env := range os.Environ() {
if strings.HasPrefix(env, "MULTI_TOKEN") {
c.MultiTokens = append(c.MultiTokens, botTokenRegex.FindStringSubmatch(env)[1])
}
}
val.FieldByName("MultiTokens").Set(reflect.ValueOf(c.MultiTokens))
}
func Load(log *zap.Logger, cmd *cobra.Command) {
log = log.Named("Config")
defer log.Info("Loaded config")
ValueOf.setupEnvVars(log, cmd)
ValueOf.LogChannelID = int64(stripInt(log, int(ValueOf.LogChannelID)))
if ValueOf.HashLength == 0 {
log.Sugar().Info("HASH_LENGTH can't be 0, defaulting to 6")
ValueOf.HashLength = 6
}
if ValueOf.HashLength > 32 {
log.Sugar().Info("HASH_LENGTH can't be more than 32, changing to 32")
ValueOf.HashLength = 32
}
if ValueOf.HashLength < 5 {
log.Sugar().Info("HASH_LENGTH can't be less than 5, defaulting to 6")
ValueOf.HashLength = 6
}
if ValueOf.StreamConcurrency <= 0 {
log.Sugar().Info("STREAM_CONCURRENCY must be greater than 0, defaulting to 8")
ValueOf.StreamConcurrency = 8
}
if ValueOf.StreamBufferCount <= 0 {
log.Sugar().Info("STREAM_BUFFER_COUNT must be greater than 0, defaulting to 16")
ValueOf.StreamBufferCount = 16
}
if ValueOf.StreamTimeoutSec <= 0 {
log.Sugar().Info("STREAM_TIMEOUT_SEC must be greater than 0, defaulting to 30 seconds")
ValueOf.StreamTimeoutSec = 30
}
if ValueOf.StreamMaxRetries <= 0 {
log.Sugar().Info("STREAM_MAX_RETRIES must be greater than 0, defaulting to 10")
ValueOf.StreamMaxRetries = 10
}
}
func getIP(public bool) (string, error) {
var ip string
var err error
if public {
ip, err = GetPublicIP()
} else {
ip, err = getInternalIP()
}
if ip == "" {
ip = "localhost"
}
if err != nil {
return "localhost", err
}
return ip, nil
}
// https://stackoverflow.com/a/23558495/15807350
func getInternalIP() (string, error) {
conn, err := net.Dial("udp", "8.8.8.8:80")
if err != nil {
return "", errors.New("no internet connection")
}
defer conn.Close()
localAddr := conn.LocalAddr().(*net.UDPAddr)
return localAddr.IP.String(), nil
}
func GetPublicIP() (string, error) {
resp, err := http.Get("https://api.ipify.org?format=text")
if err != nil {
return "", err
}
defer resp.Body.Close()
ip, err := io.ReadAll(resp.Body)
if err != nil {
return "", err
}
if !checkIfIpAccessible(string(ip)) {
return string(ip), errors.New("PORT is blocked by firewall")
}
return string(ip), nil
}
func checkIfIpAccessible(ip string) bool {
conn, err := net.Dial("tcp", ip+":80")
if err != nil {
return false
}
defer conn.Close()
return true
}
func stripInt(log *zap.Logger, a int) int {
strA := strconv.Itoa(abs(a))
lastDigits := strings.Replace(strA, "100", "", 1)
result, err := strconv.Atoi(lastDigits)
if err != nil {
log.Sugar().Fatalln(err)
return 0
}
return result
}
func abs(x int) int {
if x < 0 {
return -x
}
return x
}