func writeStateConfig() {
configMutex.Lock()
defer configMutex.Unlock()
if stateConfig == "" {
log.Debug("No state file. Not saving changes")
return
}
cfg := marshal(Registry.Config())
if len(cfg) == 0 {
return
}
lastCfg, _ := ioutil.ReadFile(stateConfig)
if bytes.Equal(cfg, lastCfg) {
log.Println("No change in config")
return
}
// We should probably write a temp file and mv for atomic update.
err := ioutil.WriteFile(stateConfig, cfg, 0644)
if err != nil {
log.Println("Error saving config state:", err)
}
}
// Stop the Service's Accept loop by closing the Listener,
// and stop all backends for this service.
func (s *Service) stop() {
s.Lock()
defer s.Unlock()
log.Printf("Stopping Listener for %s on %s:%s", s.Name, s.Network, s.Addr)
for _, backend := range s.Backends {
backend.Stop()
}
switch s.Network {
case "tcp", "tcp4", "tcp6":
// the service may have been bad, and the listener failed
if s.tcpListener == nil {
return
}
err := s.tcpListener.Close()
if err != nil {
log.Println(err)
}
case "udp", "udp4", "udp6":
if s.udpListener == nil {
return
}
err := s.udpListener.Close()
if err != nil {
log.Println(err)
}
}
}
func startAdminHTTPServer(wg *sync.WaitGroup) {
defer wg.Done()
addHandlers()
log.Println("Admin server listening on", adminListenAddr)
netw := "tcp"
if strings.HasPrefix(adminListenAddr, "/") {
netw = "unix"
// remove our old socket if we left it lying around
if stats, err := os.Stat(adminListenAddr); err == nil {
if stats.Mode()&os.ModeSocket != 0 {
os.Remove(adminListenAddr)
}
}
defer os.Remove(adminListenAddr)
}
listener, err := net.Listen(netw, adminListenAddr)
if err != nil {
log.Fatalln(err)
}
http.Serve(listener, nil)
}
// update the VirtualHost entries for this service
// only to be called from UpdateService.
func (s *ServiceRegistry) updateVHosts(service *Service, newHosts []string) {
// We could just clear the vhosts and the new list since we're doing
// this all while the registry is locked, but because we want sane log
// messages about adding remove endpoints, we have to diff the slices
// anyway.
oldHosts := service.VirtualHosts
sort.Strings(oldHosts)
sort.Strings(newHosts)
// find the relative compliments of each set of hostnames
var remove, add []string
i, j := 0, 0
for i < len(oldHosts) && j < len(newHosts) {
if oldHosts[i] != newHosts[j] {
if oldHosts[i] < newHosts[j] {
// oldHosts[i] can't be in newHosts
remove = append(remove, oldHosts[i])
i++
continue
} else {
// newHosts[j] can't be in oldHosts
add = append(add, newHosts[j])
j++
continue
}
}
i++
j++
}
if i < len(oldHosts) {
// there's more!
remove = append(remove, oldHosts[i:]...)
}
if j < len(newHosts) {
add = append(add, newHosts[j:]...)
}
// remove existing vhost entries for this service, and add new ones
for _, name := range remove {
vhost := s.vhosts[name]
if vhost != nil {
vhost.Remove(service)
}
if vhost.Len() == 0 {
log.Println("Removing empty VirtualHost", name)
delete(s.vhosts, name)
}
}
for _, name := range add {
vhost := s.vhosts[name]
if vhost == nil {
vhost = &VirtualHost{Name: name}
s.vhosts[name] = vhost
}
vhost.Add(service)
}
// and replace the list
service.VirtualHosts = newHosts
}