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
124
125
126
127
128
129
130
131
132
133
134
135
|
package main
import (
"bytes"
"errors"
"io/ioutil"
"log"
"os"
"path/filepath"
"strings"
"time"
)
type domains map[string]domain
type domainsUpdater func(domains domains)
func isDomainAllowed(domain string) bool {
if domain == "" {
return false
}
// TODO: better sanitize domain
domain = strings.ToLower(domain)
rootDomain := "." + strings.ToLower(*pagesDomain)
return !strings.HasPrefix(domain, rootDomain)
}
func (d domains) addDomain(group, project string, config *domainConfig) error {
newDomain := domain{
Group: group,
Project: project,
Config: config,
}
if config != nil {
if !isDomainAllowed(config.Domain) {
return errors.New("domain name is not allowed")
}
d[config.Domain] = newDomain
} else {
domainName := group + "." + *pagesDomain
d[domainName] = newDomain
}
return nil
}
func (d domains) readProjects(group string) (count int) {
projects, err := os.Open(filepath.Join(*pagesRoot, group))
if err != nil {
return
}
defer projects.Close()
fis, err := projects.Readdir(0)
if err != nil {
log.Println("Failed to Readdir for ", *pagesRoot, ":", err)
}
for _, project := range fis {
if !project.IsDir() {
continue
}
if strings.HasPrefix(project.Name(), ".") {
continue
}
count++
var config domainsConfig
err := config.Read(group, project.Name())
if err != nil {
continue
}
for _, domainConfig := range config.Domains {
d.addDomain(group, project.Name(), &domainConfig)
}
}
return
}
func (d domains) ReadGroups() error {
groups, err := os.Open(*pagesRoot)
if err != nil {
return err
}
defer groups.Close()
fis, err := groups.Readdir(0)
if err != nil {
log.Println("Failed to Readdir for ", *pagesRoot, ":", err)
}
for _, group := range fis {
if !group.IsDir() {
continue
}
if strings.HasPrefix(group.Name(), ".") {
continue
}
count := d.readProjects(group.Name())
if count > 0 {
d.addDomain(group.Name(), "", nil)
}
}
return nil
}
func watchDomains(updater domainsUpdater) {
lastUpdate := []byte("no-update")
for {
update, err := ioutil.ReadFile(filepath.Join(*pagesRoot, ".update"))
if bytes.Equal(lastUpdate, update) {
if err != nil {
log.Println("Failed to read update timestamp:", err)
time.Sleep(time.Second)
}
continue
}
lastUpdate = update
started := time.Now()
domains := make(domains)
domains.ReadGroups()
duration := time.Since(started)
log.Println("Updated", len(domains), "domains in", duration)
if updater != nil {
updater(domains)
}
}
}
|
