go.uber.org/fx builds the parts of waf and rproxy in internal/sww, one provider per part. Each background loop is a lifecycle hook added where its part is built. waf.Params takes every part built, and waf.New builds none. GeoJS calls back into waf, so waf exports AddLookup and GeoJSFailed, and clientGroup and banNetblock take the settings. newServer, loadStateFiles, the inBackground list and serveRProxy are gone. serve is the one hook that serves both daemons, and reports a failure to run on a channel of its own; fx's signal handling is not used. Once fx has stopped, run takes each daemon's last step: waf writes the state files, and rproxy waits for its reports. Model: opus-5-5
This commit is contained in:
1 parent
48edab5dad
commit
81bfabaf43
24 files changed
+995
-644
No files matched your search
@@ -0,0 +1,198 @@
|
||||
package sww
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"go.uber.org/fx"
|
||||
"go.uber.org/fx/fxevent"
|
||||
)
|
||||
|
||||
// shutdownTimeout is how long requests in progress may take to finish
|
||||
// once sww is told to stop, before their connections are closed.
|
||||
// runit and docker wait a little longer before they kill the process.
|
||||
const shutdownTimeout = 5 * time.Second
|
||||
|
||||
// requestLog is where a daemon's server writes the request log: stdout, and
|
||||
// the remote log sender while there is one. fx tells parts apart by type, so
|
||||
// it has a type of its own.
|
||||
type requestLog struct {
|
||||
io.Writer
|
||||
}
|
||||
|
||||
// servingFailed gets why serving failed, for run, which then stops the
|
||||
// daemon. fx tells parts apart by type, so it has a type of its own.
|
||||
type servingFailed chan error
|
||||
|
||||
// utcNow is the time the state files, the alerts and the rate limits go by.
|
||||
func utcNow() time.Time {
|
||||
return time.Now().UTC()
|
||||
}
|
||||
|
||||
// startError is why a daemon cannot start: the message its process log gives,
|
||||
// and the error it logs with it.
|
||||
type startError struct {
|
||||
message string
|
||||
err error
|
||||
}
|
||||
|
||||
func (e startError) Error() string {
|
||||
return e.message + ": " + e.err.Error()
|
||||
}
|
||||
|
||||
func (e startError) Unwrap() error {
|
||||
return e.err
|
||||
}
|
||||
|
||||
// cannotStart logs why a daemon cannot start, with the message of the
|
||||
// startError in err, and returns its exit status.
|
||||
func cannotStart(processLog *slog.Logger, err error) int {
|
||||
message, cause := "cannot start", err
|
||||
|
||||
failed, ok := errors.AsType[startError](err)
|
||||
if ok {
|
||||
message, cause = failed.message, failed.err
|
||||
}
|
||||
|
||||
processLog.Error(message, "error", cause.Error())
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
// listen listens on address, which the setting names.
|
||||
func listen(address, setting string) (net.Listener, error) {
|
||||
listener, err := (&net.ListenConfig{}).Listen(
|
||||
context.Background(), "tcp", address)
|
||||
if err != nil {
|
||||
return nil, startError{"cannot listen on " + setting, err}
|
||||
}
|
||||
|
||||
return listener, nil
|
||||
}
|
||||
|
||||
// background returns the hook that runs loop on a goroutine of its own from
|
||||
// the start, and at the stop ends it and waits for it to return.
|
||||
func background(loop func(context.Context)) fx.Hook {
|
||||
running, stop := context.WithCancel(context.Background())
|
||||
ended := make(chan struct{})
|
||||
|
||||
return fx.StartStopHook(
|
||||
func() {
|
||||
go func() {
|
||||
loop(running)
|
||||
close(ended)
|
||||
}()
|
||||
},
|
||||
func() {
|
||||
stop()
|
||||
<-ended
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
// serve serves requests on listener from the start. At the stop it gives the
|
||||
// requests in progress shutdownTimeout to finish, then closes their
|
||||
// connections. When serving fails, it logs why and sends the error to
|
||||
// failed.
|
||||
func serve(
|
||||
lc fx.Lifecycle, server *http.Server, listener net.Listener,
|
||||
processLog *slog.Logger, failed servingFailed,
|
||||
) {
|
||||
served := make(chan error, 1)
|
||||
|
||||
lc.Append(fx.Hook{
|
||||
OnStart: func(context.Context) error {
|
||||
go func() {
|
||||
err := server.Serve(listener)
|
||||
if !errors.Is(err, http.ErrServerClosed) {
|
||||
processLog.Error("serving failed", "error", err.Error())
|
||||
|
||||
failed <- err
|
||||
}
|
||||
|
||||
served <- err
|
||||
}()
|
||||
|
||||
return nil
|
||||
},
|
||||
OnStop: func(ctx context.Context) error {
|
||||
processLog.Info("stopping")
|
||||
|
||||
shutdownCtx, cancel := context.WithTimeout(ctx, shutdownTimeout)
|
||||
defer cancel()
|
||||
|
||||
err := server.Shutdown(shutdownCtx)
|
||||
if err != nil {
|
||||
processLog.Warn("requests still in progress were cut off",
|
||||
"error", err.Error())
|
||||
|
||||
_ = server.Close()
|
||||
}
|
||||
|
||||
err = <-served
|
||||
if !errors.Is(err, http.ErrServerClosed) {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// run starts app, which serves until ctx is done or serving fails, as
|
||||
// failed tells. Then it stops app and takes the daemon's last step. It
|
||||
// returns the process's exit status, 1 when serving failed, a part could
|
||||
// not stop in order or the last step failed; each logs why.
|
||||
func run(
|
||||
ctx context.Context, app *fx.App, failed servingFailed,
|
||||
processLog *slog.Logger, lastStep func() error,
|
||||
) int {
|
||||
// The hooks only start goroutines, and end them at the stop, so neither
|
||||
// is cut short by a deadline or by ctx.
|
||||
err := app.Start(context.WithoutCancel(ctx))
|
||||
if err != nil {
|
||||
return cannotStart(processLog, err)
|
||||
}
|
||||
|
||||
status := 0
|
||||
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
case <-failed:
|
||||
status = 1
|
||||
}
|
||||
|
||||
err = app.Stop(context.WithoutCancel(ctx))
|
||||
if err != nil {
|
||||
status = 1
|
||||
}
|
||||
|
||||
err = lastStep()
|
||||
if err != nil {
|
||||
status = 1
|
||||
}
|
||||
|
||||
if status == 0 {
|
||||
processLog.Info("stopped")
|
||||
}
|
||||
|
||||
return status
|
||||
}
|
||||
|
||||
// fxEventLogger returns what fx.WithLogger takes to write fx's own events to
|
||||
// processLog at debug, which the daemons' log levels normally hold back. Its
|
||||
// errors are at debug too: the daemon logs each one itself.
|
||||
func fxEventLogger(processLog *slog.Logger) func() fxevent.Logger {
|
||||
return func() fxevent.Logger {
|
||||
logger := &fxevent.SlogLogger{Logger: processLog}
|
||||
logger.UseLogLevel(slog.LevelDebug)
|
||||
logger.UseErrorLevel(slog.LevelDebug)
|
||||
|
||||
return logger
|
||||
}
|
||||
}
|
||||
+42
-63
@@ -2,12 +2,13 @@ package sww
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"log/slog"
|
||||
"net"
|
||||
"net/http"
|
||||
"os"
|
||||
|
||||
"go.uber.org/fx"
|
||||
|
||||
"sneak.berlin/go/smallwebwaf/internal/config"
|
||||
"sneak.berlin/go/smallwebwaf/internal/requestlog"
|
||||
"sneak.berlin/go/smallwebwaf/internal/rproxy"
|
||||
@@ -30,26 +31,31 @@ func RunRProxy(ctx context.Context, params Params) int {
|
||||
|
||||
cfg, err := config.RProxyFromEnvironment(params.Viper)
|
||||
if err != nil {
|
||||
processLog.Error("invalid setting", "error", err.Error())
|
||||
|
||||
return 1
|
||||
return cannotStart(processLog, startError{"invalid setting", err})
|
||||
}
|
||||
|
||||
server := rproxy.New(rproxy.Params{
|
||||
Config: cfg,
|
||||
RequestLog: params.Stdout,
|
||||
ProcessLog: processLog,
|
||||
})
|
||||
var (
|
||||
server *rproxy.Server
|
||||
listener net.Listener
|
||||
)
|
||||
|
||||
listener, err := (&net.ListenConfig{}).Listen(ctx, "tcp", cfg.ListenAddr)
|
||||
failed := make(servingFailed, 1)
|
||||
|
||||
app := fx.New(
|
||||
fx.Supply(cfg, processLog, requestLog{params.Stdout}, failed),
|
||||
fx.Provide(
|
||||
newRProxyServer,
|
||||
func(server *rproxy.Server) *http.Server { return server.Server },
|
||||
newRProxyListener,
|
||||
),
|
||||
fx.Invoke(serve),
|
||||
fx.Populate(&server, &listener),
|
||||
fx.WithLogger(fxEventLogger(processLog)),
|
||||
)
|
||||
|
||||
err = app.Err()
|
||||
if err != nil {
|
||||
processLog.Error(
|
||||
"cannot listen on SWW_RPROXY_LISTEN_ADDR",
|
||||
"error",
|
||||
err.Error(),
|
||||
)
|
||||
|
||||
return 1
|
||||
return cannotStart(processLog, err)
|
||||
}
|
||||
|
||||
processLog.Info("starting",
|
||||
@@ -57,52 +63,25 @@ func RunRProxy(ctx context.Context, params Params) int {
|
||||
"address", listener.Addr().String(),
|
||||
"settings", cfg)
|
||||
|
||||
return serveRProxy(ctx, server, listener, processLog)
|
||||
return run(ctx, app, failed, processLog, func() error {
|
||||
server.WaitForReports()
|
||||
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// serveRProxy serves requests on listener until ctx is done, and then stops as
|
||||
// RunRProxy says.
|
||||
func serveRProxy(
|
||||
ctx context.Context, server *rproxy.Server, listener net.Listener,
|
||||
processLog *slog.Logger,
|
||||
) int {
|
||||
served := make(chan error, 1)
|
||||
|
||||
go func() {
|
||||
served <- server.Serve(listener)
|
||||
}()
|
||||
|
||||
select {
|
||||
case err := <-served:
|
||||
processLog.Error("serving failed", "error", err.Error())
|
||||
|
||||
return 1
|
||||
case <-ctx.Done():
|
||||
}
|
||||
|
||||
processLog.Info("stopping")
|
||||
|
||||
shutdownCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx),
|
||||
shutdownTimeout)
|
||||
defer cancel()
|
||||
|
||||
err := server.Shutdown(shutdownCtx)
|
||||
if err != nil {
|
||||
processLog.Warn("requests still in progress were cut off",
|
||||
"error", err.Error())
|
||||
|
||||
_ = server.Close()
|
||||
}
|
||||
|
||||
err = <-served
|
||||
if !errors.Is(err, http.ErrServerClosed) {
|
||||
processLog.Error("serving failed", "error", err.Error())
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
server.WaitForReports()
|
||||
processLog.Info("stopped")
|
||||
|
||||
return 0
|
||||
// newRProxyServer returns the server rproxy runs.
|
||||
func newRProxyServer(
|
||||
cfg *config.RProxy, out requestLog, processLog *slog.Logger,
|
||||
) *rproxy.Server {
|
||||
return rproxy.New(rproxy.Params{
|
||||
Config: cfg,
|
||||
RequestLog: out,
|
||||
ProcessLog: processLog,
|
||||
})
|
||||
}
|
||||
|
||||
// newRProxyListener listens on SWW_RPROXY_LISTEN_ADDR.
|
||||
func newRProxyListener(cfg *config.RProxy) (net.Listener, error) {
|
||||
return listen(cfg.ListenAddr, "SWW_RPROXY_LISTEN_ADDR")
|
||||
}
|
||||
+2
-395
@@ -4,47 +4,23 @@
|
||||
// stop, and then stops in an orderly way, writing the state and cache files.
|
||||
// `sww rproxy` reads rproxy's settings alone, and runs the reverse proxy in
|
||||
// front of one app that asks waf about each request. `sww healthcheck` is the
|
||||
// container's health check.
|
||||
// container's health check. fx builds the parts of each daemon, starts their
|
||||
// background work and stops it.
|
||||
package sww
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/spf13/viper"
|
||||
|
||||
"sneak.berlin/go/smallwebwaf/internal/alerts"
|
||||
"sneak.berlin/go/smallwebwaf/internal/config"
|
||||
"sneak.berlin/go/smallwebwaf/internal/coreruleset"
|
||||
"sneak.berlin/go/smallwebwaf/internal/geojs"
|
||||
"sneak.berlin/go/smallwebwaf/internal/lookup"
|
||||
"sneak.berlin/go/smallwebwaf/internal/remotelog"
|
||||
"sneak.berlin/go/smallwebwaf/internal/reputation"
|
||||
"sneak.berlin/go/smallwebwaf/internal/requestlog"
|
||||
"sneak.berlin/go/smallwebwaf/internal/rules"
|
||||
"sneak.berlin/go/smallwebwaf/internal/state"
|
||||
"sneak.berlin/go/smallwebwaf/internal/waf"
|
||||
)
|
||||
|
||||
// shutdownTimeout is how long requests in progress may take to finish
|
||||
// once sww is told to stop, before their connections are closed.
|
||||
// runit and docker wait a little longer before they kill the process.
|
||||
const shutdownTimeout = 5 * time.Second
|
||||
|
||||
// remoteLogStopTimeout is how long, as waf stops, the log lines still
|
||||
// waiting are sent to SWW_WAF_LOG_REMOTE_URL before they are given up. stdout has
|
||||
// carried them.
|
||||
const remoteLogStopTimeout = 2 * time.Second
|
||||
|
||||
// usageStatus is the exit status with no command, or one sww does not
|
||||
// know.
|
||||
const usageStatus = 2
|
||||
@@ -107,372 +83,3 @@ func printUsage(w io.Writer) int {
|
||||
|
||||
return usageStatus
|
||||
}
|
||||
|
||||
// RunWAF is `sww waf`: it reads the settings, the rule files,
|
||||
// the lookup database and the state and cache files, then serves requests until
|
||||
// ctx is done. It returns the process's exit status, 1 when waf cannot start.
|
||||
func RunWAF(ctx context.Context, params Params) int {
|
||||
// Until the settings are read, the one message is an invalid setting's
|
||||
// error, which every SWW_WAF_LOG_LEVEL lets through.
|
||||
processLog := requestlog.NewProcessLogger(params.Stdout,
|
||||
config.InstanceName(params.Viper), slog.LevelError)
|
||||
|
||||
cfg, err := config.WAFFromEnvironment(params.Viper)
|
||||
if err != nil {
|
||||
return cannotStart(processLog, "invalid setting", err)
|
||||
}
|
||||
|
||||
// While SWW_WAF_LOG_REMOTE_URL is set, every line on stdout from here on
|
||||
// is sent there too.
|
||||
stdout := params.Stdout
|
||||
|
||||
var remote *remotelog.Sender
|
||||
|
||||
if cfg.LogRemoteURL != nil {
|
||||
remote = newRemoteLogSender(cfg)
|
||||
stdout = io.MultiWriter(params.Stdout, remote)
|
||||
}
|
||||
|
||||
processLog = requestlog.NewProcessLogger(
|
||||
stdout,
|
||||
cfg.InstanceName,
|
||||
cfg.LogLevel,
|
||||
)
|
||||
|
||||
if remote != nil {
|
||||
stopSending := startSending(ctx, remote, processLog)
|
||||
defer stopSending()
|
||||
}
|
||||
|
||||
return runWAFWithSettings(
|
||||
ctx,
|
||||
params.Version,
|
||||
cfg,
|
||||
stdout,
|
||||
remote,
|
||||
processLog,
|
||||
)
|
||||
}
|
||||
|
||||
// runWAFWithSettings is the rest of RunWAF once the settings are read and
|
||||
// the process log goes where they say. remote is nil unless
|
||||
// SWW_WAF_LOG_REMOTE_URL is set.
|
||||
func runWAFWithSettings(
|
||||
ctx context.Context,
|
||||
version string,
|
||||
cfg *config.WAF,
|
||||
stdout io.Writer,
|
||||
remote *remotelog.Sender,
|
||||
processLog *slog.Logger,
|
||||
) int {
|
||||
// The state files and the alerts give times in UTC.
|
||||
now := func() time.Time { return time.Now().UTC() }
|
||||
|
||||
alertQueue := newAlertQueue(cfg, now, processLog)
|
||||
|
||||
ruleFiles, err := rules.Load(rules.Params{
|
||||
Dir: cfg.RuleFilesDir,
|
||||
Enabled: cfg.RuleFilesEnabled,
|
||||
ProcessLog: processLog,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
if err != nil {
|
||||
return cannotStart(processLog, "cannot use the rule files", err)
|
||||
}
|
||||
|
||||
crs, err := waf.NewCoreRuleSet(cfg)
|
||||
if err != nil {
|
||||
return cannotStart(processLog, "cannot use the Core Rule Set", err)
|
||||
}
|
||||
|
||||
server, err := newServer(
|
||||
cfg,
|
||||
stdout,
|
||||
processLog,
|
||||
now,
|
||||
ruleFiles,
|
||||
alertQueue,
|
||||
crs,
|
||||
)
|
||||
if err != nil {
|
||||
return cannotStart(processLog, "cannot use the lookup database", err)
|
||||
}
|
||||
|
||||
if remote != nil {
|
||||
server.Metrics.AddRemoteLog(remote)
|
||||
}
|
||||
|
||||
files, err := loadStateFiles(cfg, server, alertQueue, now, processLog)
|
||||
if err != nil {
|
||||
return cannotStart(
|
||||
processLog,
|
||||
"cannot use the state and cache files",
|
||||
err,
|
||||
)
|
||||
}
|
||||
|
||||
listener, err := (&net.ListenConfig{}).Listen(ctx, "tcp", cfg.ListenAddr)
|
||||
if err != nil {
|
||||
return cannotStart(
|
||||
processLog,
|
||||
"cannot listen on SWW_WAF_LISTEN_ADDR",
|
||||
err,
|
||||
)
|
||||
}
|
||||
|
||||
processLog.Info("starting",
|
||||
"version", version,
|
||||
"address", listener.Addr().String(),
|
||||
"settings", cfg)
|
||||
|
||||
return serve(
|
||||
ctx,
|
||||
server,
|
||||
listener,
|
||||
files,
|
||||
ruleFiles,
|
||||
alertQueue,
|
||||
processLog,
|
||||
)
|
||||
}
|
||||
|
||||
// cannotStart logs why waf cannot start, and returns its exit status.
|
||||
func cannotStart(processLog *slog.Logger, message string, err error) int {
|
||||
processLog.Error(message, "error", err.Error())
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
// newServer returns the server waf runs, with the metrics of the alerts,
|
||||
// after reading the lookup database while SWW_WAF_LOOKUP_SOURCE is file. A lookup
|
||||
// database that cannot be read is an error.
|
||||
func newServer(
|
||||
cfg *config.WAF, stdout io.Writer, processLog *slog.Logger,
|
||||
now func() time.Time, ruleFiles *rules.Files, alertQueue *alerts.Queue,
|
||||
crs *coreruleset.CoreRuleSet,
|
||||
) (*waf.Server, error) {
|
||||
var lookupFile *lookup.File
|
||||
|
||||
if cfg.LookupSource == "file" {
|
||||
var err error
|
||||
|
||||
lookupFile, err = lookup.OpenFile(lookup.FileParams{
|
||||
Path: cfg.LookupDBPath,
|
||||
Now: now,
|
||||
ProcessLog: processLog,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
server := waf.New(waf.Params{
|
||||
Config: cfg,
|
||||
RequestLog: stdout,
|
||||
ProcessLog: processLog,
|
||||
GeoJSURL: geojs.URL,
|
||||
AbuseIPDBURL: reputation.AbuseIPDBURL,
|
||||
LookupFile: lookupFile,
|
||||
CoreRuleSet: crs,
|
||||
Now: now,
|
||||
Rules: ruleFiles,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
server.Metrics.AddAlerts(alertQueue)
|
||||
|
||||
if lookupFile != nil {
|
||||
server.Metrics.AddLookupFile(
|
||||
lookupFile.LastRead,
|
||||
lookupFile.ReadFailures,
|
||||
)
|
||||
}
|
||||
|
||||
return server, nil
|
||||
}
|
||||
|
||||
// loadStateFiles reads the state and cache files into the parts of server and
|
||||
// into alertQueue, as state.Load does.
|
||||
func loadStateFiles(
|
||||
cfg *config.WAF, server *waf.Server, alertQueue *alerts.Queue,
|
||||
now func() time.Time, processLog *slog.Logger,
|
||||
) (*state.Files, error) {
|
||||
return state.Load(state.Params{
|
||||
Dir: cfg.StateDir,
|
||||
CacheDir: cfg.CacheDir,
|
||||
BansWriteDelay: cfg.BansWriteDelay,
|
||||
WriteInterval: cfg.StateWriteInterval,
|
||||
Ledger: server.Ledger,
|
||||
Limiter: server.Limiter,
|
||||
GeoJS: server.GeoJS,
|
||||
Lists: server.Lists,
|
||||
DNSBL: server.DNSBL,
|
||||
AbuseIPDB: server.AbuseIPDB,
|
||||
RouteWatch: server.RouteWatch,
|
||||
Alerts: alertQueue,
|
||||
Anomalies: server.Anomalies,
|
||||
Now: now,
|
||||
ProcessLog: processLog,
|
||||
Metrics: server.Metrics,
|
||||
})
|
||||
}
|
||||
|
||||
// newAlertQueue returns the queue of the alerts to the webhook, Slack and
|
||||
// ntfy, with the settings for them.
|
||||
func newAlertQueue(
|
||||
cfg *config.WAF, now func() time.Time, processLog *slog.Logger,
|
||||
) *alerts.Queue {
|
||||
return alerts.New(alerts.Params{
|
||||
WebhookURL: cfg.AlertWebhookURL,
|
||||
WebhookHeaders: cfg.AlertWebhookHeaders,
|
||||
SlackURL: cfg.AlertSlackWebhookURL,
|
||||
NtfyURL: cfg.AlertNtfyURL,
|
||||
NtfyToken: cfg.AlertNtfyToken,
|
||||
Events: cfg.AlertEvents,
|
||||
Cooldown: cfg.AlertCooldown,
|
||||
MaxPerHour: cfg.AlertMaxPerHour,
|
||||
Instance: cfg.InstanceName,
|
||||
Now: now,
|
||||
ProcessLog: processLog,
|
||||
})
|
||||
}
|
||||
|
||||
// newRemoteLogSender returns a sender of the log lines to
|
||||
// SWW_WAF_LOG_REMOTE_URL, with the settings for it.
|
||||
func newRemoteLogSender(cfg *config.WAF) *remotelog.Sender {
|
||||
return remotelog.New(remotelog.Params{
|
||||
URL: cfg.LogRemoteURL,
|
||||
RootCAs: cfg.LogRemoteTLSCAs,
|
||||
BufferLines: cfg.LogRemoteBufferLines,
|
||||
Facility: cfg.LogRemoteFacility,
|
||||
AppName: cfg.LogRemoteAppName,
|
||||
})
|
||||
}
|
||||
|
||||
// startSending runs remote until the function it returns is called, which
|
||||
// then waits at most remoteLogStopTimeout for the lines still waiting to
|
||||
// be sent. Sending goes on after ctx is done, so that the lines written
|
||||
// while sww stops are sent too.
|
||||
func startSending(
|
||||
ctx context.Context, remote *remotelog.Sender, processLog *slog.Logger,
|
||||
) func() {
|
||||
sending, stop := context.WithCancel(context.WithoutCancel(ctx))
|
||||
sent := make(chan struct{})
|
||||
|
||||
go func() {
|
||||
remote.Run(sending, processLog)
|
||||
close(sent)
|
||||
}()
|
||||
|
||||
return func() {
|
||||
stop()
|
||||
|
||||
select {
|
||||
case <-sent:
|
||||
case <-time.After(remoteLogStopTimeout):
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// serve serves requests on listener, writes the state and cache files as they
|
||||
// are due, takes in an admin's edits of them, reads the rule files again as
|
||||
// they change, and the lookup database when it is replaced, fetches the
|
||||
// lists the settings name by URL as they are due, and sends the alerts,
|
||||
// until ctx is done. Then it gives the requests in progress
|
||||
// shutdownTimeout to finish, and writes every state and cache file,
|
||||
// alerts.json with the alerts still waiting.
|
||||
func serve(
|
||||
ctx context.Context, server *waf.Server, listener net.Listener,
|
||||
files *state.Files, ruleFiles *rules.Files, alertQueue *alerts.Queue,
|
||||
processLog *slog.Logger,
|
||||
) int {
|
||||
served := make(chan error, 1)
|
||||
|
||||
go func() {
|
||||
served <- server.Serve(listener)
|
||||
}()
|
||||
|
||||
writing, stopWriting := context.WithCancel(ctx)
|
||||
defer stopWriting()
|
||||
|
||||
written := inBackground(func() { files.Run(writing) })
|
||||
watched := inBackground(func() { files.Watch(writing) })
|
||||
rulesWatched := inBackground(func() { ruleFiles.Watch(writing) })
|
||||
lookupFileWatched := inBackground(func() {
|
||||
if server.LookupFile != nil {
|
||||
server.LookupFile.Watch(writing)
|
||||
}
|
||||
})
|
||||
listsFetched := inBackground(func() { server.Lists.Run(writing) })
|
||||
alertsSent := inBackground(func() { alertQueue.Run(writing) })
|
||||
|
||||
select {
|
||||
case err := <-served:
|
||||
processLog.Error("serving failed", "error", err.Error())
|
||||
|
||||
return 1
|
||||
case <-ctx.Done():
|
||||
}
|
||||
|
||||
processLog.Info("stopping")
|
||||
|
||||
shutdownCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx),
|
||||
shutdownTimeout)
|
||||
defer cancel()
|
||||
|
||||
err := server.Shutdown(shutdownCtx)
|
||||
if err != nil {
|
||||
processLog.Warn("requests still in progress were cut off",
|
||||
"error", err.Error())
|
||||
|
||||
_ = server.Close()
|
||||
}
|
||||
|
||||
err = <-served
|
||||
if !errors.Is(err, http.ErrServerClosed) {
|
||||
processLog.Error("serving failed", "error", err.Error())
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
// Run and Watch have ended, so nothing else reads or writes the
|
||||
// files, and no alert is being sent, so that alerts.json keeps every
|
||||
// alert not yet sent. Every request has ended too, but for one cut off
|
||||
// because Shutdown timed out, which adds to its client's history only as
|
||||
// it ends. That can be after this write, and then that request is missing
|
||||
// from clients.json.
|
||||
<-written
|
||||
<-watched
|
||||
<-rulesWatched
|
||||
<-lookupFileWatched
|
||||
<-listsFetched
|
||||
<-alertsSent
|
||||
|
||||
err = files.WriteAll()
|
||||
if err != nil {
|
||||
processLog.Error(
|
||||
"writing the state and cache files failed",
|
||||
"error",
|
||||
err.Error(),
|
||||
)
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
processLog.Info("stopped")
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
// inBackground runs task on a goroutine of its own, and returns a channel
|
||||
// that is closed once task has returned.
|
||||
func inBackground(task func()) <-chan struct{} {
|
||||
done := make(chan struct{})
|
||||
|
||||
go func() {
|
||||
task()
|
||||
close(done)
|
||||
}()
|
||||
|
||||
return done
|
||||
}
|
||||
@@ -0,0 +1,480 @@
|
||||
package sww
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"go.uber.org/fx"
|
||||
|
||||
"sneak.berlin/go/smallwebwaf/internal/alerts"
|
||||
"sneak.berlin/go/smallwebwaf/internal/anomaly"
|
||||
"sneak.berlin/go/smallwebwaf/internal/bans"
|
||||
"sneak.berlin/go/smallwebwaf/internal/config"
|
||||
"sneak.berlin/go/smallwebwaf/internal/coreruleset"
|
||||
"sneak.berlin/go/smallwebwaf/internal/geojs"
|
||||
"sneak.berlin/go/smallwebwaf/internal/lookup"
|
||||
"sneak.berlin/go/smallwebwaf/internal/metrics"
|
||||
"sneak.berlin/go/smallwebwaf/internal/ratelimit"
|
||||
"sneak.berlin/go/smallwebwaf/internal/remotelog"
|
||||
"sneak.berlin/go/smallwebwaf/internal/reputation"
|
||||
"sneak.berlin/go/smallwebwaf/internal/requestlog"
|
||||
"sneak.berlin/go/smallwebwaf/internal/routewatch"
|
||||
"sneak.berlin/go/smallwebwaf/internal/rules"
|
||||
"sneak.berlin/go/smallwebwaf/internal/state"
|
||||
"sneak.berlin/go/smallwebwaf/internal/waf"
|
||||
)
|
||||
|
||||
// remoteLogStopTimeout is how long, as waf stops, the log lines still
|
||||
// waiting are sent to SWW_WAF_LOG_REMOTE_URL before they are given up. stdout has
|
||||
// carried them.
|
||||
const remoteLogStopTimeout = 2 * time.Second
|
||||
|
||||
// RunWAF is `sww waf`: it reads the settings, the rule files,
|
||||
// the lookup database and the state and cache files, then serves requests until
|
||||
// ctx is done. Then it gives the requests in progress shutdownTimeout to
|
||||
// finish, ends its background work and writes every state and cache file,
|
||||
// alerts.json with the alerts still waiting. It returns the process's exit
|
||||
// status, 1 when waf cannot start or stop in order.
|
||||
func RunWAF(ctx context.Context, params Params) int {
|
||||
// Until the settings are read, the one message is an invalid setting's
|
||||
// error, which every SWW_WAF_LOG_LEVEL lets through.
|
||||
processLog := requestlog.NewProcessLogger(params.Stdout,
|
||||
config.InstanceName(params.Viper), slog.LevelError)
|
||||
|
||||
cfg, err := config.WAFFromEnvironment(params.Viper)
|
||||
if err != nil {
|
||||
return cannotStart(processLog, startError{"invalid setting", err})
|
||||
}
|
||||
|
||||
// While SWW_WAF_LOG_REMOTE_URL is set, every line on stdout from here on
|
||||
// is sent there too. The sender runs before any part is built, so that it
|
||||
// sends why waf cannot start.
|
||||
stdout := params.Stdout
|
||||
|
||||
var remote *remotelog.Sender
|
||||
|
||||
if cfg.LogRemoteURL != nil {
|
||||
remote = newRemoteLogSender(cfg)
|
||||
stdout = io.MultiWriter(params.Stdout, remote)
|
||||
}
|
||||
|
||||
processLog = requestlog.NewProcessLogger(
|
||||
stdout,
|
||||
cfg.InstanceName,
|
||||
cfg.LogLevel,
|
||||
)
|
||||
|
||||
if remote != nil {
|
||||
stopSending := startSending(ctx, remote, processLog)
|
||||
defer stopSending()
|
||||
}
|
||||
|
||||
var (
|
||||
files *state.Files
|
||||
listener net.Listener
|
||||
)
|
||||
|
||||
failed := make(servingFailed, 1)
|
||||
|
||||
app := fx.New(
|
||||
fx.Supply(cfg, processLog, requestLog{stdout}, remote, failed),
|
||||
fx.Provide(
|
||||
newAlertQueue, newRuleFiles, newCoreRuleSet, newLookupFile,
|
||||
newLimiter, newLedger, newAnomalyCounters,
|
||||
newLists, newDNSBL, newAbuseIPDB, newRouteWatch,
|
||||
newMetrics, newGeoJS, newWAFServer,
|
||||
func(server *waf.Server) *http.Server { return server.Server },
|
||||
newWAFListener, newStateFiles,
|
||||
),
|
||||
// fx stops hooks in the reverse of the order they were added in. The
|
||||
// state files are read before serving is set up, so that serving
|
||||
// stops before their loops do.
|
||||
fx.Populate(&files),
|
||||
fx.Invoke(serve),
|
||||
fx.Populate(&listener),
|
||||
fx.WithLogger(fxEventLogger(processLog)),
|
||||
)
|
||||
|
||||
err = app.Err()
|
||||
if err != nil {
|
||||
return cannotStart(processLog, err)
|
||||
}
|
||||
|
||||
processLog.Info("starting",
|
||||
"version", params.Version,
|
||||
"address", listener.Addr().String(),
|
||||
"settings", cfg)
|
||||
|
||||
// The last write follows the stop of every hook, and so the end of every
|
||||
// loop that changes the state or raises an alert. A hook of the state
|
||||
// files would stop before the loops of the parts built ahead of them.
|
||||
return run(ctx, app, failed, processLog, func() error {
|
||||
err := files.WriteAll()
|
||||
if err != nil {
|
||||
processLog.Error("writing the state and cache files failed",
|
||||
"error", err.Error())
|
||||
}
|
||||
|
||||
return err
|
||||
})
|
||||
}
|
||||
|
||||
// newAlertQueue returns the queue of the alerts to the webhook, Slack and
|
||||
// ntfy, with the settings for them. Until waf stops, it sends them.
|
||||
func newAlertQueue(
|
||||
lc fx.Lifecycle, cfg *config.WAF, processLog *slog.Logger,
|
||||
) *alerts.Queue {
|
||||
alertQueue := alerts.New(alerts.Params{
|
||||
WebhookURL: cfg.AlertWebhookURL,
|
||||
WebhookHeaders: cfg.AlertWebhookHeaders,
|
||||
SlackURL: cfg.AlertSlackWebhookURL,
|
||||
NtfyURL: cfg.AlertNtfyURL,
|
||||
NtfyToken: cfg.AlertNtfyToken,
|
||||
Events: cfg.AlertEvents,
|
||||
Cooldown: cfg.AlertCooldown,
|
||||
MaxPerHour: cfg.AlertMaxPerHour,
|
||||
Instance: cfg.InstanceName,
|
||||
Now: utcNow,
|
||||
ProcessLog: processLog,
|
||||
})
|
||||
|
||||
lc.Append(background(alertQueue.Run))
|
||||
|
||||
return alertQueue
|
||||
}
|
||||
|
||||
// newRuleFiles reads the rule files, and reads them again as they change
|
||||
// until waf stops.
|
||||
func newRuleFiles(
|
||||
lc fx.Lifecycle, cfg *config.WAF, processLog *slog.Logger,
|
||||
alertQueue *alerts.Queue,
|
||||
) (*rules.Files, error) {
|
||||
ruleFiles, err := rules.Load(rules.Params{
|
||||
Dir: cfg.RuleFilesDir,
|
||||
Enabled: cfg.RuleFilesEnabled,
|
||||
ProcessLog: processLog,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, startError{"cannot use the rule files", err}
|
||||
}
|
||||
|
||||
lc.Append(background(ruleFiles.Watch))
|
||||
|
||||
return ruleFiles, nil
|
||||
}
|
||||
|
||||
// newCoreRuleSet returns the Core Rule Set, as waf.NewCoreRuleSet does.
|
||||
func newCoreRuleSet(cfg *config.WAF) (*coreruleset.CoreRuleSet, error) {
|
||||
crs, err := waf.NewCoreRuleSet(cfg)
|
||||
if err != nil {
|
||||
return nil, startError{"cannot use the Core Rule Set", err}
|
||||
}
|
||||
|
||||
return crs, nil
|
||||
}
|
||||
|
||||
// newLookupFile reads the lookup database while SWW_WAF_LOOKUP_SOURCE is
|
||||
// file, and reads it again when it is replaced until waf stops. It returns
|
||||
// nil while the source is anything else.
|
||||
func newLookupFile(
|
||||
lc fx.Lifecycle, cfg *config.WAF, processLog *slog.Logger,
|
||||
alertQueue *alerts.Queue,
|
||||
) (*lookup.File, error) {
|
||||
if cfg.LookupSource != "file" {
|
||||
return nil, nil //nolint:nilnil // no lookup database, and no error
|
||||
}
|
||||
|
||||
lookupFile, err := lookup.OpenFile(lookup.FileParams{
|
||||
Path: cfg.LookupDBPath,
|
||||
Now: utcNow,
|
||||
ProcessLog: processLog,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, startError{"cannot use the lookup database", err}
|
||||
}
|
||||
|
||||
lc.Append(background(lookupFile.Watch))
|
||||
|
||||
return lookupFile, nil
|
||||
}
|
||||
|
||||
// newLimiter returns the table of clients, with the rate and byte limits.
|
||||
func newLimiter(cfg *config.WAF) *ratelimit.Limiter {
|
||||
return ratelimit.New(ratelimit.Limits{
|
||||
PerMinute: cfg.RateLimitPerMinute,
|
||||
PerHour: cfg.RateLimitPerHour,
|
||||
PerDay: cfg.RateLimitPerDay,
|
||||
BytesPerMinute: cfg.BytesLimitPerMinute,
|
||||
BytesPerHour: cfg.BytesLimitPerHour,
|
||||
BytesPerDay: cfg.BytesLimitPerDay,
|
||||
}, cfg.MaxTrackedClients)
|
||||
}
|
||||
|
||||
// newLedger returns the ledger of the bans, with the settings for them.
|
||||
func newLedger(cfg *config.WAF) *bans.Ledger {
|
||||
return bans.New(bans.Params{
|
||||
LimitBanDuration: cfg.LimitBanDuration,
|
||||
LimitBanRepeatWindow: cfg.LimitBanRepeatWindow,
|
||||
LimitBanPermanentAbove: cfg.LimitBanPermanentAbove,
|
||||
AttackBanDuration: cfg.AttackBanDuration,
|
||||
MaxBans: cfg.MaxBans,
|
||||
})
|
||||
}
|
||||
|
||||
// newAnomalyCounters returns the counters of the anomaly thresholds.
|
||||
func newAnomalyCounters(
|
||||
cfg *config.WAF, alertQueue *alerts.Queue,
|
||||
) *anomaly.Counters {
|
||||
return anomaly.New(anomaly.Params{
|
||||
Client: cfg.AnomalyClient,
|
||||
Net: cfg.AnomalyNet,
|
||||
ASN: cfg.AnomalyASN,
|
||||
Total: cfg.AnomalyTotal,
|
||||
WatchedNet: cfg.AnomalyWatchedNet,
|
||||
NetV4Prefix: cfg.AnomalyNetV4Prefix,
|
||||
NetV6Prefix: cfg.AnomalyNetV6Prefix,
|
||||
NamedNetblocks: cfg.AnomalyWatchedNets,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
}
|
||||
|
||||
// newLists returns the lists the settings name by URL, none fetched yet.
|
||||
// Until waf stops, it fetches them as they are due.
|
||||
func newLists(
|
||||
lc fx.Lifecycle, cfg *config.WAF, processLog *slog.Logger,
|
||||
alertQueue *alerts.Queue,
|
||||
) *reputation.Lists {
|
||||
lists := reputation.New(reputation.Params{
|
||||
BlocklistURLs: cfg.BlocklistURLs,
|
||||
Refresh: cfg.BlocklistRefresh,
|
||||
ASNLimitPercentURL: cfg.ASNLimitPercentURL,
|
||||
TagLists: cfg.TagLists,
|
||||
Now: utcNow,
|
||||
ProcessLog: processLog,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
|
||||
lc.Append(background(lists.Run))
|
||||
|
||||
return lists
|
||||
}
|
||||
|
||||
// newDNSBL returns what asks the DNSBL zones, none asked yet.
|
||||
func newDNSBL(
|
||||
cfg *config.WAF, processLog *slog.Logger, alertQueue *alerts.Queue,
|
||||
) *reputation.DNSBL {
|
||||
return reputation.NewDNSBL(reputation.DNSBLParams{
|
||||
Zones: cfg.DNSBLZones,
|
||||
Resolver: cfg.DNSBLResolver,
|
||||
CacheTTL: cfg.IPReputationCacheTTL,
|
||||
Timeout: cfg.DNSBLAbuseIPDBTimeout,
|
||||
Now: utcNow,
|
||||
ProcessLog: processLog,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
}
|
||||
|
||||
// newAbuseIPDB returns what checks clients with AbuseIPDB while
|
||||
// SWW_WAF_ABUSEIPDB_KEY is set, none checked yet.
|
||||
func newAbuseIPDB(
|
||||
cfg *config.WAF, processLog *slog.Logger, alertQueue *alerts.Queue,
|
||||
) *reputation.AbuseIPDB {
|
||||
return reputation.NewAbuseIPDB(reputation.AbuseIPDBParams{
|
||||
URL: reputation.AbuseIPDBURL,
|
||||
Key: cfg.AbuseIPDBKey,
|
||||
MinScore: cfg.AbuseIPDBMinScore,
|
||||
DailyBudget: cfg.AbuseIPDBDailyBudget,
|
||||
CacheTTL: cfg.IPReputationCacheTTL,
|
||||
Timeout: cfg.DNSBLAbuseIPDBTimeout,
|
||||
Now: utcNow,
|
||||
ProcessLog: processLog,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
}
|
||||
|
||||
// newRouteWatch returns what asks routewatch about clients, or nil while
|
||||
// SWW_WAF_ROUTEWATCH_URL is unset.
|
||||
func newRouteWatch(
|
||||
cfg *config.WAF, processLog *slog.Logger,
|
||||
) *routewatch.Client {
|
||||
if cfg.RouteWatchURL == "" {
|
||||
return nil
|
||||
}
|
||||
|
||||
return routewatch.New(routewatch.Params{
|
||||
URL: cfg.RouteWatchURL,
|
||||
Now: utcNow,
|
||||
ProcessLog: processLog,
|
||||
})
|
||||
}
|
||||
|
||||
// newMetrics returns the metrics, with those read from the other parts as
|
||||
// the metrics are asked for: AbuseIPDB's while SWW_WAF_ABUSEIPDB_KEY is set,
|
||||
// the lookup database's while there is one, and the remote log sender's
|
||||
// while there is one.
|
||||
func newMetrics(
|
||||
cfg *config.WAF, ledger *bans.Ledger, limiter *ratelimit.Limiter,
|
||||
ruleFiles *rules.Files, lists *reputation.Lists,
|
||||
dnsbl *reputation.DNSBL, abuseIPDB *reputation.AbuseIPDB,
|
||||
alertQueue *alerts.Queue, lookupFile *lookup.File,
|
||||
remote *remotelog.Sender,
|
||||
) *metrics.Metrics {
|
||||
m := metrics.New(cfg.MetricsBusiestCountriesAndASNs, cfg.InstanceName)
|
||||
m.AddBansAndClients(ledger, limiter, utcNow)
|
||||
m.AddRules(ruleFiles)
|
||||
m.AddReputation(lists, dnsbl)
|
||||
|
||||
if cfg.AbuseIPDBKey != "" {
|
||||
m.AddAbuseIPDB(abuseIPDB)
|
||||
}
|
||||
|
||||
m.AddAlerts(alertQueue)
|
||||
|
||||
if lookupFile != nil {
|
||||
m.AddLookupFile(lookupFile.LastRead, lookupFile.ReadFailures)
|
||||
}
|
||||
|
||||
if remote != nil {
|
||||
m.AddRemoteLog(remote)
|
||||
}
|
||||
|
||||
return m
|
||||
}
|
||||
|
||||
// newGeoJS returns what looks clients up at GeoJS, none looked up yet. Each
|
||||
// answer goes to the limiter and the ledger, as waf.AddLookup says, and each
|
||||
// failure is handled as waf.GeoJSFailed says.
|
||||
func newGeoJS(
|
||||
cfg *config.WAF, m *metrics.Metrics, limiter *ratelimit.Limiter,
|
||||
ledger *bans.Ledger, alertQueue *alerts.Queue, processLog *slog.Logger,
|
||||
) *geojs.GeoJS {
|
||||
return geojs.New(geojs.Params{
|
||||
URL: geojs.URL,
|
||||
Answered: func(answer geojs.Answer) {
|
||||
waf.AddLookup(cfg, limiter, ledger, answer)
|
||||
},
|
||||
Now: utcNow,
|
||||
Asked: m.GeoJSRequests.Inc,
|
||||
Failed: func(err error, askingAgainIn time.Duration) {
|
||||
waf.GeoJSFailed(processLog, alertQueue, m, err, askingAgainIn)
|
||||
},
|
||||
WentWithoutAnswer: m.RequestsWithoutGeoJSAnswer.Inc,
|
||||
})
|
||||
}
|
||||
|
||||
// newWAFServer returns the server waf runs, with its parts.
|
||||
func newWAFServer(
|
||||
cfg *config.WAF, out requestLog, processLog *slog.Logger,
|
||||
m *metrics.Metrics, limiter *ratelimit.Limiter, ledger *bans.Ledger,
|
||||
anomalies *anomaly.Counters, lists *reputation.Lists,
|
||||
dnsbl *reputation.DNSBL, abuseIPDB *reputation.AbuseIPDB,
|
||||
routeWatch *routewatch.Client, geoJS *geojs.GeoJS,
|
||||
lookupFile *lookup.File, crs *coreruleset.CoreRuleSet,
|
||||
ruleFiles *rules.Files, alertQueue *alerts.Queue,
|
||||
) *waf.Server {
|
||||
return waf.New(waf.Params{
|
||||
Config: cfg,
|
||||
RequestLog: out,
|
||||
ProcessLog: processLog,
|
||||
Metrics: m,
|
||||
Limiter: limiter,
|
||||
Ledger: ledger,
|
||||
Anomalies: anomalies,
|
||||
Lists: lists,
|
||||
DNSBL: dnsbl,
|
||||
AbuseIPDB: abuseIPDB,
|
||||
RouteWatch: routeWatch,
|
||||
GeoJS: geoJS,
|
||||
LookupFile: lookupFile,
|
||||
CoreRuleSet: crs,
|
||||
Now: utcNow,
|
||||
Rules: ruleFiles,
|
||||
Alerts: alertQueue,
|
||||
})
|
||||
}
|
||||
|
||||
// newWAFListener listens on SWW_WAF_LISTEN_ADDR.
|
||||
func newWAFListener(cfg *config.WAF) (net.Listener, error) {
|
||||
return listen(cfg.ListenAddr, "SWW_WAF_LISTEN_ADDR")
|
||||
}
|
||||
|
||||
// newStateFiles reads the state and cache files into the parts and the
|
||||
// alert queue, as state.Load does. Until waf stops, it writes them as they
|
||||
// are due and takes in an admin's edits of them.
|
||||
func newStateFiles(
|
||||
lc fx.Lifecycle, cfg *config.WAF, processLog *slog.Logger,
|
||||
m *metrics.Metrics, ledger *bans.Ledger, limiter *ratelimit.Limiter,
|
||||
geoJS *geojs.GeoJS, lists *reputation.Lists, dnsbl *reputation.DNSBL,
|
||||
abuseIPDB *reputation.AbuseIPDB, routeWatch *routewatch.Client,
|
||||
alertQueue *alerts.Queue, anomalies *anomaly.Counters,
|
||||
) (*state.Files, error) {
|
||||
files, err := state.Load(state.Params{
|
||||
Dir: cfg.StateDir,
|
||||
CacheDir: cfg.CacheDir,
|
||||
BansWriteDelay: cfg.BansWriteDelay,
|
||||
WriteInterval: cfg.StateWriteInterval,
|
||||
Ledger: ledger,
|
||||
Limiter: limiter,
|
||||
GeoJS: geoJS,
|
||||
Lists: lists,
|
||||
DNSBL: dnsbl,
|
||||
AbuseIPDB: abuseIPDB,
|
||||
RouteWatch: routeWatch,
|
||||
Alerts: alertQueue,
|
||||
Anomalies: anomalies,
|
||||
Now: utcNow,
|
||||
ProcessLog: processLog,
|
||||
Metrics: m,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, startError{"cannot use the state and cache files", err}
|
||||
}
|
||||
|
||||
lc.Append(background(files.Run))
|
||||
lc.Append(background(files.Watch))
|
||||
|
||||
return files, nil
|
||||
}
|
||||
|
||||
// newRemoteLogSender returns a sender of the log lines to
|
||||
// SWW_WAF_LOG_REMOTE_URL, with the settings for it.
|
||||
func newRemoteLogSender(cfg *config.WAF) *remotelog.Sender {
|
||||
return remotelog.New(remotelog.Params{
|
||||
URL: cfg.LogRemoteURL,
|
||||
RootCAs: cfg.LogRemoteTLSCAs,
|
||||
BufferLines: cfg.LogRemoteBufferLines,
|
||||
Facility: cfg.LogRemoteFacility,
|
||||
AppName: cfg.LogRemoteAppName,
|
||||
})
|
||||
}
|
||||
|
||||
// startSending runs remote until the function it returns is called, which
|
||||
// then waits at most remoteLogStopTimeout for the lines still waiting to
|
||||
// be sent. Sending goes on after ctx is done, so that the lines written
|
||||
// while sww stops are sent too.
|
||||
func startSending(
|
||||
ctx context.Context, remote *remotelog.Sender, processLog *slog.Logger,
|
||||
) func() {
|
||||
sending, stop := context.WithCancel(context.WithoutCancel(ctx))
|
||||
sent := make(chan struct{})
|
||||
|
||||
go func() {
|
||||
remote.Run(sending, processLog)
|
||||
close(sent)
|
||||
}()
|
||||
|
||||
return func() {
|
||||
stop()
|
||||
|
||||
select {
|
||||
case <-sent:
|
||||
case <-time.After(remoteLogStopTimeout):
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user