Move config files and folders

server/config.go

@@ -0,0 +1,77 @@
+package server
+
+import (
+	"time"
+)
+
+// Defines default config settings
+const (
+	DefaultListenHTTP                = ":80"
+	DefaultCacheDuration             = 12 * time.Hour
+	DefaultKeepaliveInterval         = 30 * time.Second
+	DefaultManagerInterval           = time.Minute
+	DefaultAtSenderInterval          = 10 * time.Second
+	DefaultMinDelay                  = 10 * time.Second
+	DefaultMaxDelay                  = 3 * 24 * time.Hour
+	DefaultMessageLimit              = 512
+	DefaultFirebaseKeepaliveInterval = time.Hour
+)
+
+// Defines all the limits
+// - global topic limit: max number of topics overall
+// - per visitor request limit: max number of PUT/GET/.. requests (here: 60 requests bucket, replenished at a rate of one per 10 seconds)
+// - per visitor subscription limit: max number of subscriptions (active HTTP connections) per per-visitor/IP
+const (
+	DefaultGlobalTopicLimit             = 5000
+	DefaultVisitorRequestLimitBurst     = 60
+	DefaultVisitorRequestLimitReplenish = 10 * time.Second
+	DefaultVisitorSubscriptionLimit     = 30
+)
+
+// Config is the main config struct for the application. Use New to instantiate a default config struct.
+type Config struct {
+	ListenHTTP                   string
+	ListenHTTPS                  string
+	KeyFile                      string
+	CertFile                     string
+	FirebaseKeyFile              string
+	CacheFile                    string
+	CacheDuration                time.Duration
+	KeepaliveInterval            time.Duration
+	ManagerInterval              time.Duration
+	AtSenderInterval             time.Duration
+	FirebaseKeepaliveInterval    time.Duration
+	MessageLimit                 int
+	MinDelay                     time.Duration
+	MaxDelay                     time.Duration
+	GlobalTopicLimit             int
+	VisitorRequestLimitBurst     int
+	VisitorRequestLimitReplenish time.Duration
+	VisitorSubscriptionLimit     int
+	BehindProxy                  bool
+}
+
+// New instantiates a default new config
+func NewConfig(listenHTTP string) *Config {
+	return &Config{
+		ListenHTTP:                   listenHTTP,
+		ListenHTTPS:                  "",
+		KeyFile:                      "",
+		CertFile:                     "",
+		FirebaseKeyFile:              "",
+		CacheFile:                    "",
+		CacheDuration:                DefaultCacheDuration,
+		KeepaliveInterval:            DefaultKeepaliveInterval,
+		ManagerInterval:              DefaultManagerInterval,
+		MessageLimit:                 DefaultMessageLimit,
+		MinDelay:                     DefaultMinDelay,
+		MaxDelay:                     DefaultMaxDelay,
+		AtSenderInterval:             DefaultAtSenderInterval,
+		FirebaseKeepaliveInterval:    DefaultFirebaseKeepaliveInterval,
+		GlobalTopicLimit:             DefaultGlobalTopicLimit,
+		VisitorRequestLimitBurst:     DefaultVisitorRequestLimitBurst,
+		VisitorRequestLimitReplenish: DefaultVisitorRequestLimitReplenish,
+		VisitorSubscriptionLimit:     DefaultVisitorSubscriptionLimit,
+		BehindProxy:                  false,
+	}
+}

server/config_test.go

@@ -0,0 +1,12 @@
+package server_test
+
+import (
+	"github.com/stretchr/testify/assert"
+	"heckel.io/ntfy/server"
+	"testing"
+)
+
+func TestConfig_New(t *testing.T) {
+	c := server.NewConfig(":1234")
+	assert.Equal(t, ":1234", c.ListenHTTP)
+}

server/ntfy.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=ntfy server
+After=network.target
+
+[Service]
+User=ntfy
+Group=ntfy
+ExecStart=/usr/bin/ntfy serve
+Restart=on-failure
+AmbientCapabilities=CAP_NET_BIND_SERVICE
+LimitNOFILE=10000
+
+[Install]
+WantedBy=multi-user.target

server/server.go

@@ -9,7 +9,6 @@ import (
 	"firebase.google.com/go/messaging"
 	"fmt"
 	"google.golang.org/api/option"
-	"heckel.io/ntfy/config"
 	"heckel.io/ntfy/util"
 	"html/template"
 	"io"
@@ -28,7 +27,7 @@ import (
 
 // Server is the main server, providing the UI and API for ntfy
 type Server struct {
-	config   *config.Config
+	config   *Config
 	topics   map[string]*topic
 	visitors map[string]*visitor
 	firebase subscriber
@@ -112,7 +111,7 @@ const (
 
 // New instantiates a new Server. It creates the cache and adds a Firebase
 // subscriber (if configured).
-func New(conf *config.Config) (*Server, error) {
+func New(conf *Config) (*Server, error) {
 	var firebaseSubscriber subscriber
 	if conf.FirebaseKeyFile != "" {
 		var err error
@@ -138,7 +137,7 @@ func New(conf *config.Config) (*Server, error) {
 	}, nil
 }
 
-func createCache(conf *config.Config) (cache, error) {
+func createCache(conf *Config) (cache, error) {
 	if conf.CacheDuration == 0 {
 		return newNopCache(), nil
 	} else if conf.CacheFile != "" {
@@ -147,7 +146,7 @@ func createCache(conf *config.Config) (cache, error) {
 	return newMemCache(), nil
 }
 
-func createFirebaseSubscriber(conf *config.Config) (subscriber, error) {
+func createFirebaseSubscriber(conf *Config) (subscriber, error) {
 	fb, err := firebase.NewApp(context.Background(), nil, option.WithCredentialsFile(conf.FirebaseKeyFile))
 	if err != nil {
 		return nil, err

server/server.yml

@@ -0,0 +1,70 @@
+# ntfy server config file
+
+# Listen address for the HTTP & HTTPS web server. If "listen-https" is set, you must also
+# set "key-file" and "cert-file".
+# Format: <hostname>:<port>
+#
+# listen-http: ":80"
+# listen-https:
+
+# Path to the private key & cert file for the HTTPS web server. Not used if "listen-https" is not set.
+#
+# key-file:
+# cert-file:
+
+# If set, also publish messages to a Firebase Cloud Messaging (FCM) topic for your app.
+# This is optional and only required to save battery when using the Android app.
+#
+# firebase-key-file: <filename>
+
+# If set, messages are cached in a local SQLite database instead of only in-memory. This
+# allows for service restarts without losing messages in support of the since= parameter.
+#
+# To disable the cache entirely (on-disk/in-memory), set "cache-duration" to 0.
+#
+# Note: If you are running ntfy with systemd, make sure this cache file is owned by the
+#       ntfy user and group by running: chown ntfy.ntfy <filename>.
+#
+# cache-file: <filename>
+
+# Duration for which messages will be buffered before they are deleted.
+# This is required to support the "since=..." and "poll=1" parameter.
+#
+# You can disable the cache entirely by setting this to 0.
+#
+# cache-duration: 12h
+
+# Interval in which keepalive messages are sent to the client. This is to prevent
+# intermediaries closing the connection for inactivity.
+#
+# Note that the Android app has a hardcoded timeout at 77s, so it should be less than that.
+#
+# keepalive-interval: 30s
+
+# Interval in which the manager prunes old messages, deletes topics
+# and prints the stats.
+#
+# manager-interval: 1m
+
+# Rate limiting: Total number of topics before the server rejects new topics.
+#
+# global-topic-limit: 5000
+
+# Rate limiting: Number of subscriptions per visitor (IP address)
+#
+# visitor-subscription-limit: 30
+
+# Rate limiting: Allowed GET/PUT/POST requests per second, per visitor:
+# - visitor-request-limit-burst is the initial bucket of requests each visitor has
+# - visitor-request-limit-replenish is the rate at which the bucket is refilled
+#
+# visitor-request-limit-burst: 60
+# visitor-request-limit-replenish: 10s
+
+# If set, the X-Forwarded-For header is used to determine the visitor IP address
+# instead of the remote address of the connection.
+#
+# WARNING: If you are behind a proxy, you must set this, otherwise all visitors are rate limited
+#          as if they are one.
+#
+# behind-proxy: false

server/visitor.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"golang.org/x/time/rate"
-	"heckel.io/ntfy/config"
 	"heckel.io/ntfy/util"
 	"sync"
 	"time"
@@ -14,14 +13,14 @@ const (
 
 // visitor represents an API user, and its associated rate.Limiter used for rate limiting
 type visitor struct {
-	config        *config.Config
+	config        *Config
 	limiter       *rate.Limiter
 	subscriptions *util.Limiter
 	seen          time.Time
 	mu            sync.Mutex
 }
 
-func newVisitor(conf *config.Config) *visitor {
+func newVisitor(conf *Config) *visitor {
 	return &visitor{
 		config:        conf,
 		limiter:       rate.NewLimiter(rate.Every(conf.VisitorRequestLimitReplenish), conf.VisitorRequestLimitBurst),