2019-12-15 14:58:01 -05:00
|
|
|
// Copyright 2015 Matthew Holt and The Caddy Authors
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
package logging
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"net"
|
2021-05-19 16:14:03 -05:00
|
|
|
"os"
|
2020-05-28 11:40:14 -05:00
|
|
|
"sync"
|
2021-05-19 16:14:03 -05:00
|
|
|
"time"
|
2019-12-15 14:58:01 -05:00
|
|
|
|
|
|
|
"github.com/caddyserver/caddy/v2"
|
2020-02-26 00:00:33 -05:00
|
|
|
"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
|
2019-12-15 14:58:01 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
caddy.RegisterModule(NetWriter{})
|
|
|
|
}
|
|
|
|
|
2021-05-19 16:14:03 -05:00
|
|
|
// NetWriter implements a log writer that outputs to a network socket. If
|
|
|
|
// the socket goes down, it will dump logs to stderr while it attempts to
|
|
|
|
// reconnect.
|
2019-12-15 14:58:01 -05:00
|
|
|
type NetWriter struct {
|
2021-05-19 16:14:03 -05:00
|
|
|
// The address of the network socket to which to connect.
|
2019-12-15 14:58:01 -05:00
|
|
|
Address string `json:"address,omitempty"`
|
|
|
|
|
2021-05-19 16:14:03 -05:00
|
|
|
// The timeout to wait while connecting to the socket.
|
|
|
|
DialTimeout caddy.Duration `json:"dial_timeout,omitempty"`
|
|
|
|
|
2023-05-04 17:29:03 -05:00
|
|
|
// If enabled, allow connections errors when first opening the
|
|
|
|
// writer. The error and subsequent log entries will be reported
|
|
|
|
// to stderr instead until a connection can be re-established.
|
|
|
|
SoftStart bool `json:"soft_start,omitempty"`
|
|
|
|
|
2020-04-07 09:33:45 -05:00
|
|
|
addr caddy.NetworkAddress
|
2019-12-15 14:58:01 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (NetWriter) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
|
|
|
ID: "caddy.logging.writers.net",
|
|
|
|
New: func() caddy.Module { return new(NetWriter) },
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Provision sets up the module.
|
|
|
|
func (nw *NetWriter) Provision(ctx caddy.Context) error {
|
|
|
|
repl := caddy.NewReplacer()
|
|
|
|
address, err := repl.ReplaceOrErr(nw.Address, true, true)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("invalid host in address: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
nw.addr, err = caddy.ParseNetworkAddress(address)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("parsing network address '%s': %v", address, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if nw.addr.PortRangeSize() != 1 {
|
|
|
|
return fmt.Errorf("multiple ports not supported")
|
|
|
|
}
|
|
|
|
|
2021-05-19 16:14:03 -05:00
|
|
|
if nw.DialTimeout < 0 {
|
|
|
|
return fmt.Errorf("timeout cannot be less than 0")
|
|
|
|
}
|
|
|
|
|
2019-12-15 14:58:01 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (nw NetWriter) String() string {
|
|
|
|
return nw.addr.String()
|
|
|
|
}
|
|
|
|
|
|
|
|
// WriterKey returns a unique key representing this nw.
|
|
|
|
func (nw NetWriter) WriterKey() string {
|
|
|
|
return nw.addr.String()
|
|
|
|
}
|
|
|
|
|
|
|
|
// OpenWriter opens a new network connection.
|
|
|
|
func (nw NetWriter) OpenWriter() (io.WriteCloser, error) {
|
2021-05-19 16:14:03 -05:00
|
|
|
reconn := &redialerConn{
|
|
|
|
nw: nw,
|
|
|
|
timeout: time.Duration(nw.DialTimeout),
|
|
|
|
}
|
2020-05-28 11:40:14 -05:00
|
|
|
conn, err := reconn.dial()
|
|
|
|
if err != nil {
|
2023-05-04 17:30:34 -05:00
|
|
|
if !nw.SoftStart {
|
|
|
|
return nil, err
|
|
|
|
}
|
2023-05-04 17:29:03 -05:00
|
|
|
// don't block config load if remote is down or some other external problem;
|
|
|
|
// we can dump logs to stderr for now (see issue #5520)
|
|
|
|
fmt.Fprintf(os.Stderr, "[ERROR] net log writer failed to connect: %v (will retry connection and print errors here in the meantime)\n", err)
|
2020-05-28 11:40:14 -05:00
|
|
|
}
|
|
|
|
reconn.connMu.Lock()
|
|
|
|
reconn.Conn = conn
|
|
|
|
reconn.connMu.Unlock()
|
|
|
|
return reconn, nil
|
2019-12-15 14:58:01 -05:00
|
|
|
}
|
|
|
|
|
2020-02-26 00:00:33 -05:00
|
|
|
// UnmarshalCaddyfile sets up the handler from Caddyfile tokens. Syntax:
|
|
|
|
//
|
2022-11-14 11:38:02 -05:00
|
|
|
// net <address> {
|
|
|
|
// dial_timeout <duration>
|
2023-05-04 17:29:03 -05:00
|
|
|
// soft_start
|
2022-11-14 11:38:02 -05:00
|
|
|
// }
|
2020-02-26 00:00:33 -05:00
|
|
|
func (nw *NetWriter) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
|
|
|
for d.Next() {
|
|
|
|
if !d.NextArg() {
|
|
|
|
return d.ArgErr()
|
|
|
|
}
|
|
|
|
nw.Address = d.Val()
|
|
|
|
if d.NextArg() {
|
|
|
|
return d.ArgErr()
|
|
|
|
}
|
2021-05-19 16:14:03 -05:00
|
|
|
for nesting := d.Nesting(); d.NextBlock(nesting); {
|
|
|
|
switch d.Val() {
|
|
|
|
case "dial_timeout":
|
|
|
|
if !d.NextArg() {
|
|
|
|
return d.ArgErr()
|
|
|
|
}
|
|
|
|
timeout, err := caddy.ParseDuration(d.Val())
|
|
|
|
if err != nil {
|
|
|
|
return d.Errf("invalid duration: %s", d.Val())
|
|
|
|
}
|
|
|
|
if d.NextArg() {
|
|
|
|
return d.ArgErr()
|
|
|
|
}
|
|
|
|
nw.DialTimeout = caddy.Duration(timeout)
|
2023-05-04 17:29:03 -05:00
|
|
|
|
|
|
|
case "soft_start":
|
|
|
|
if d.NextArg() {
|
|
|
|
return d.ArgErr()
|
|
|
|
}
|
|
|
|
nw.SoftStart = true
|
2021-05-19 16:14:03 -05:00
|
|
|
}
|
|
|
|
}
|
2020-02-26 00:00:33 -05:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-05-28 11:40:14 -05:00
|
|
|
// redialerConn wraps an underlying Conn so that if any
|
|
|
|
// writes fail, the connection is redialed and the write
|
|
|
|
// is retried.
|
|
|
|
type redialerConn struct {
|
|
|
|
net.Conn
|
2021-05-19 16:14:03 -05:00
|
|
|
connMu sync.RWMutex
|
|
|
|
nw NetWriter
|
|
|
|
timeout time.Duration
|
|
|
|
lastRedial time.Time
|
2020-05-28 11:40:14 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Write wraps the underlying Conn.Write method, but if that fails,
|
|
|
|
// it will re-dial the connection anew and try writing again.
|
|
|
|
func (reconn *redialerConn) Write(b []byte) (n int, err error) {
|
|
|
|
reconn.connMu.RLock()
|
|
|
|
conn := reconn.Conn
|
|
|
|
reconn.connMu.RUnlock()
|
2023-05-04 17:29:03 -05:00
|
|
|
if conn != nil {
|
|
|
|
if n, err = conn.Write(b); err == nil {
|
|
|
|
return
|
|
|
|
}
|
2020-05-28 11:40:14 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// problem with the connection - lock it and try to fix it
|
|
|
|
reconn.connMu.Lock()
|
|
|
|
defer reconn.connMu.Unlock()
|
|
|
|
|
|
|
|
// if multiple concurrent writes failed on the same broken conn, then
|
|
|
|
// one of them might have already re-dialed by now; try writing again
|
2023-05-04 17:29:03 -05:00
|
|
|
if reconn.Conn != nil {
|
|
|
|
if n, err = reconn.Conn.Write(b); err == nil {
|
|
|
|
return
|
|
|
|
}
|
2020-05-28 11:40:14 -05:00
|
|
|
}
|
|
|
|
|
2021-05-19 16:14:03 -05:00
|
|
|
// there's still a problem, so try to re-attempt dialing the socket
|
|
|
|
// if some time has passed in which the issue could have potentially
|
|
|
|
// been resolved - we don't want to block at every single log
|
|
|
|
// emission (!) - see discussion in #4111
|
|
|
|
if time.Since(reconn.lastRedial) > 10*time.Second {
|
|
|
|
reconn.lastRedial = time.Now()
|
|
|
|
conn2, err2 := reconn.dial()
|
|
|
|
if err2 != nil {
|
|
|
|
// logger socket still offline; instead of discarding the log, dump it to stderr
|
|
|
|
os.Stderr.Write(b)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if n, err = conn2.Write(b); err == nil {
|
2023-05-04 17:29:03 -05:00
|
|
|
if reconn.Conn != nil {
|
|
|
|
reconn.Conn.Close()
|
|
|
|
}
|
2021-05-19 16:14:03 -05:00
|
|
|
reconn.Conn = conn2
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// last redial attempt was too recent; just dump to stderr for now
|
|
|
|
os.Stderr.Write(b)
|
2020-05-28 11:40:14 -05:00
|
|
|
}
|
2021-05-19 16:14:03 -05:00
|
|
|
|
2020-05-28 11:40:14 -05:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func (reconn *redialerConn) dial() (net.Conn, error) {
|
2021-05-19 16:14:03 -05:00
|
|
|
return net.DialTimeout(reconn.nw.addr.Network, reconn.nw.addr.JoinHostPort(0), reconn.timeout)
|
2020-05-28 11:40:14 -05:00
|
|
|
}
|
|
|
|
|
2019-12-15 14:58:01 -05:00
|
|
|
// Interface guards
|
|
|
|
var (
|
2020-02-26 00:00:33 -05:00
|
|
|
_ caddy.Provisioner = (*NetWriter)(nil)
|
|
|
|
_ caddy.WriterOpener = (*NetWriter)(nil)
|
|
|
|
_ caddyfile.Unmarshaler = (*NetWriter)(nil)
|
2019-12-15 14:58:01 -05:00
|
|
|
)
|