webdav-server/main.go at main · d7z-project/webdav-server · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package main

import (
	"context"
	"errors"
	"flag"
	"log/slog"
	"net"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"code.d7z.net/packages/webdav-server/assets"
	"code.d7z.net/packages/webdav-server/common"
	"code.d7z.net/packages/webdav-server/dav"
	"code.d7z.net/packages/webdav-server/index"
	"code.d7z.net/packages/webdav-server/preview"
	"code.d7z.net/packages/webdav-server/sftp_service"
	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
)

var (
	config = "./config.yml"
	debug  bool
)

func init() {
	flag.StringVar(&config, "config", config, "config file")
	flag.BoolVar(&debug, "debug", debug, "debug mode")
	flag.Parse()
	if debug {
		slog.SetLogLoggerLevel(slog.LevelDebug)
	} else {
		slog.SetLogLoggerLevel(slog.LevelWarn)
	}
}

func main() {
	cfg, err := common.LoadConfig(config)
	if err != nil {
		slog.Error("load config err", "err", err)
		os.Exit(1)
	}
	osCtx, cancel := context.WithCancel(context.Background())
	defer cancel()
	go func() {
		defer cancel()
		sig := make(chan os.Signal, 1)
		signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
		defer signal.Stop(sig)
		defer close(sig)
		<-sig
	}()
	ctx, err := common.NewContext(osCtx, cfg)
	if err != nil {
		slog.Error("new context err", "err", err)
		os.Exit(1)
	}

	route := chi.NewMux()
	route.Use(middleware.RequestID)
	route.Use(middleware.RealIP)
	route.Use(middleware.Recoverer)
	if debug {
		route.Use(middleware.Logger)
	}

	// Static files
	route.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.FS(assets.StaticFS))))

	if cfg.Webdav.Enabled {
		slog.Info("webdav enabled")
		route.Route(cfg.Webdav.Prefix, dav.WithWebdav(ctx))
	}
	route.Route("/preview", preview.WithPreview(ctx))
	index.WithIndex(ctx, route)

	httpListen, err := net.Listen("tcp", cfg.Bind)
	if err != nil {
		slog.Error("listen http err", "err", err)
		os.Exit(1)
	}
	var sftpListen net.Listener
	var sftpServer *sftp_service.SFTPServer
	if cfg.SFTP.Enabled {
		sftpServer, err = sftp_service.NewSFTPServer(ctx)
		if err != nil {
			slog.Error("sftp init err", "err", err)
			os.Exit(1)
		}
		sftpListen, err = net.Listen("tcp", cfg.SFTP.Bind)
		if err != nil {
			slog.Error("listen sftp err", "err", err)
			os.Exit(1)
		}

	}
	server := http.Server{
		Addr:    cfg.Bind,
		Handler: route,
	}
	go func() {
		if err := server.Serve(httpListen); err != nil && !errors.Is(err, http.ErrServerClosed) {
			slog.Error("serve err", "err", err)
		}
	}()
	go func() {
		if sftpServer != nil && sftpListen != nil {
			slog.Info("sftp enabled", "addr", cfg.SFTP.Bind)
			sftpServer.Serve(ctx, sftpListen)
		}
	}()
	<-osCtx.Done()
	timeout, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := server.Shutdown(timeout); err != nil {
		slog.Error("shutdown err", "err", err)
		os.Exit(1)
	}
}