Clean up remove caddy refs (#139)

* Changed reference to Caddy over to CoreDNS

* Removing references to caddy

* Fixed misleading error message to reference coredns

* Cleaning up references to caddy

* Adding clean and deps targets

Muscle memory is resulting in "make clean" commands.

* Adding test target to makefile

* More "Caddy" cleanup

core/assets/path_test.go

@@ -7,6 +7,6 @@ import (
 
 func TestPath(t *testing.T) {
 	if actual := Path(); !strings.HasSuffix(actual, ".coredns") {
-		t.Errorf("Expected path to be a .caddy folder, got: %v", actual)
+		t.Errorf("Expected path to be a .coredns folder, got: %v", actual)
 	}
 }

core/caddy.go

@@ -1,16 +1,16 @@
-// Package caddy implements the Caddy web server as a service
+// Package caddy implements the CoreDNS web server as a service
 // in your own Go programs.
 //
 // To use this package, follow a few simple steps:
 //
 //   1. Set the AppName and AppVersion variables.
-//   2. Call LoadCaddyfile() to get the Caddyfile (it
+//   2. Call LoadCorefile() to get the Corefile (it
 //      might have been piped in as part of a restart).
-//      You should pass in your own Caddyfile loader.
-//   3. Call caddy.Start() to start Caddy, caddy.Stop()
+//      You should pass in your own Corefile loader.
+//   3. Call caddy.Start() to start CoreDNS, caddy.Stop()
 //      to stop it, or caddy.Restart() to restart it.
 //
-// You should use caddy.Wait() to wait for all Caddy servers
+// You should use caddy.Wait() to wait for all CoreDNS servers
 // to quit before your process exits.
 package core
 
@@ -52,14 +52,14 @@ var (
 )
 
 var (
-	// caddyfile is the input configuration text used for this process
-	caddyfile Input
+	// corefile is the input configuration text used for this process
+	corefile Input
 
-	// caddyfileMu protects caddyfile during changes
-	caddyfileMu sync.Mutex
+	// corefileMu protects corefile during changes
+	corefileMu sync.Mutex
 
 	// errIncompleteRestart occurs if this process is a fork
-	// of the parent but no Caddyfile was piped in
+	// of the parent but no Corefile was piped in
 	errIncompleteRestart = errors.New("incomplete restart")
 
 	// servers is a list of all the currently-listening servers
@@ -75,9 +75,9 @@ var (
 	// a graceful restart; it is used to map listeners to their
 	// index in the list of inherited file descriptors. This
 	// variable is not safe for concurrent access.
-	loadedGob caddyfileGob
+	loadedGob corefileGob
 
-	// startedBefore should be set to true if caddy has been started
+	// startedBefore should be set to true if CoreDNS has been started
 	// at least once (does not indicate whether currently running).
 	startedBefore bool
 )
@@ -91,8 +91,8 @@ const (
 	DefaultRoot = "."
 )
 
-// Start starts Caddy with the given Caddyfile. If cdyfile
-// is nil, the LoadCaddyfile function will be called to get
+// Start starts CoreDNS with the given Corefile. If crfile
+// is nil, the LoadCorefile function will be called to get
 // one.
 //
 // This function blocks until all the servers are listening.
@@ -101,12 +101,12 @@ const (
 // restart more than once within the duration of the graceful
 // cutoff (i.e. the child process called Start a first time,
 // then called Stop, then Start again within the first 5 seconds
-// or however long GracefulTimeout is) and the Caddyfiles have
+// or however long GracefulTimeout is) and the Corefiles have
 // at least one listener address in common, the second Start
 // may fail with "address already in use" as there's no
 // guarantee that the parent process has relinquished the
 // address before the grace period ends.
-func Start(cdyfile Input) (err error) {
+func Start(crfile Input) (err error) {
 	// If we return with no errors, we must do two things: tell the
 	// parent that we succeeded and write to the pidfile.
 	defer func() {
@@ -122,19 +122,19 @@ func Start(cdyfile Input) (err error) {
 	}()
 
 	// Input must never be nil; try to load something
-	if cdyfile == nil {
-		cdyfile, err = LoadCaddyfile(nil)
+	if crfile == nil {
+		crfile, err = LoadCorefile(nil)
 		if err != nil {
 			return err
 		}
 	}
 
-	caddyfileMu.Lock()
-	caddyfile = cdyfile
-	caddyfileMu.Unlock()
+	corefileMu.Lock()
+	corefile = crfile
+	corefileMu.Unlock()
 
 	// load the server configs (activates Let's Encrypt)
-	configs, err := loadConfigs(path.Base(cdyfile.Path()), bytes.NewReader(cdyfile.Body()))
+	configs, err := loadConfigs(path.Base(crfile.Path()), bytes.NewReader(crfile.Body()))
 	if err != nil {
 		return err
 	}
@@ -303,14 +303,14 @@ func Wait() {
 	wg.Wait()
 }
 
-// LoadCaddyfile loads a Caddyfile, prioritizing a Caddyfile
+// LoadCorefile loads a Corefile, prioritizing a Corefile
 // piped from stdin as part of a restart (only happens on first call
-// to LoadCaddyfile). If it is not a restart, this function tries
+// to LoadCorefile). If it is not a restart, this function tries
 // calling the user's loader function, and if that returns nil, then
 // this function resorts to the default configuration. Thus, if there
 // are no other errors, this function always returns at least the
-// default Caddyfile.
-func LoadCaddyfile(loader func() (Input, error)) (cdyfile Input, err error) {
+// default Corefile.
+func LoadCorefile(loader func() (Input, error)) (crfile Input, err error) {
 	// If we are a fork, finishing the restart is highest priority;
 	// piped input is required in this case.
 	if IsRestart() {
@@ -318,30 +318,30 @@ func LoadCaddyfile(loader func() (Input, error)) (cdyfile Input, err error) {
 		if err != nil {
 			return nil, err
 		}
-		cdyfile = loadedGob.Caddyfile
+		crfile = loadedGob.Corefile
 		atomic.StoreInt32(https.OnDemandIssuedCount, loadedGob.OnDemandTLSCertsIssued)
 	}
 
 	// Try user's loader
-	if cdyfile == nil && loader != nil {
-		cdyfile, err = loader()
+	if crfile == nil && loader != nil {
+		crfile, err = loader()
 	}
 
 	// Otherwise revert to default
-	if cdyfile == nil {
-		cdyfile = DefaultInput()
+	if crfile == nil {
+		crfile = DefaultInput()
 	}
 
 	return
 }
 
-// CaddyfileFromPipe loads the Caddyfile input from f if f is
+// CorefileFromPipe loads the Corefile input from f if f is
 // not interactive input. f is assumed to be a pipe or stream,
 // such as os.Stdin. If f is not a pipe, no error is returned
 // but the Input value will be nil. An error is only returned
 // if there was an error reading the pipe, even if the length
 // of what was read is 0.
-func CaddyfileFromPipe(f *os.File) (Input, error) {
+func CorefileFromPipe(f *os.File) (Input, error) {
 	fi, err := f.Stat()
 	if err == nil && fi.Mode()&os.ModeCharDevice == 0 {
 		// Note that a non-nil error is not a problem. Windows
@@ -354,7 +354,7 @@ func CaddyfileFromPipe(f *os.File) (Input, error) {
 		if err != nil {
 			return nil, err
 		}
-		return CaddyfileInput{
+		return CorefileInput{
 			Contents: confBody,
 			Filepath: f.Name(),
 		}, nil
@@ -365,20 +365,20 @@ func CaddyfileFromPipe(f *os.File) (Input, error) {
 	return nil, nil
 }
 
-// Caddyfile returns the current Caddyfile
-func Caddyfile() Input {
-	caddyfileMu.Lock()
-	defer caddyfileMu.Unlock()
-	return caddyfile
+// Corefile returns the current Corefile
+func Corefile() Input {
+	corefileMu.Lock()
+	defer corefileMu.Unlock()
+	return corefile
 }
 
-// Input represents a Caddyfile; its contents and file path
+// Input represents a Corefile; its contents and file path
 // (which should include the file name at the end of the path).
 // If path does not apply (e.g. piped input) you may use
 // any understandable value. The path is mainly used for logging,
 // error messages, and debugging.
 type Input interface {
-	// Gets the Caddyfile contents
+	// Gets the Corefile contents
 	Body() []byte
 
 	// Gets the path to the origin file
@@ -394,8 +394,8 @@ type Input interface {
 // with Stop(). It just takes a normal Corefile as input.
 func TestServer(t *testing.T, corefile string) (*server.Server, error) {
 
-	cdyfile := CaddyfileInput{Contents: []byte(corefile)}
-	configs, err := loadConfigs(path.Base(cdyfile.Path()), bytes.NewReader(cdyfile.Body()))
+	crfile := CorefileInput{Contents: []byte(corefile)}
+	configs, err := loadConfigs(path.Base(crfile.Path()), bytes.NewReader(crfile.Body()))
 	if err != nil {
 		return nil, err
 	}

core/caddy_test.go

@@ -2,10 +2,10 @@ package core
 
 /*
 func TestCaddyStartStop(t *testing.T) {
-	caddyfile := "localhost:1984"
+	corefile := "localhost:1984"
 
 	for i := 0; i < 2; i++ {
-		err := Start(CaddyfileInput{Contents: []byte(caddyfile)})
+		err := Start(CorefileInput{Contents: []byte(corefile)})
 		if err != nil {
 			t.Fatalf("Error starting, iteration %d: %v", i, err)
 		}

core/config.go

@@ -23,7 +23,7 @@ func loadConfigsUpToIncludingTLS(filename string, input io.Reader) ([]server.Con
 	var configs []server.Config
 
 	// Each server block represents similar hosts/addresses, since they
-	// were grouped together in the Caddyfile.
+	// were grouped together in the Corefile.
 	serverBlocks, err := parse.ServerBlocks(filename, input, true)
 	if err != nil {
 		return nil, nil, 0, err
@@ -304,12 +304,12 @@ func validDirective(d string) bool {
 	return false
 }
 
-// DefaultInput returns the default Caddyfile input
+// DefaultInput returns the default Corefile input
 // to use when it is otherwise empty or missing.
 // It uses the default host and port and root.
-func DefaultInput() CaddyfileInput {
+func DefaultInput() CorefileInput {
 	port := Port
-	return CaddyfileInput{
+	return CorefileInput{
 		Contents: []byte(fmt.Sprintf("%s:%s\nroot %s", Host, port, Root)),
 	}
 }

core/directives.go

@@ -68,7 +68,7 @@ var directiveOrder = []directive{
 	{"proxy", setup.Proxy},
 }
 
-// RegisterDirective adds the given directive to caddy's list of directives.
+// RegisterDirective adds the given directive to CoreDNS's list of directives.
 // Pass the name of a directive you want it to be placed after,
 // otherwise it will be placed at the bottom of the stack.
 func RegisterDirective(name string, setup SetupFunc, after string) {

core/helpers.go

@@ -57,24 +57,24 @@ func signalSuccessToParent() {
 // signaled once; doing so more than once breaks whatever socket is
 // at fd 4 (the reason for this is still unclear - to reproduce,
 // call Stop() and Start() in succession at least once after a
-// restart, then try loading first host of Caddyfile in the browser).
+// restart, then try loading first host of Corefile in the browser).
 // Do not use this directly - call signalSuccessToParent instead.
 var signalParentOnce sync.Once
 
-// caddyfileGob maps bind address to index of the file descriptor
+// corefileGob maps bind address to index of the file descriptor
 // in the Files array passed to the child process. It also contains
-// the caddyfile contents and other state needed by the new process.
+// the corefile contents and other state needed by the new process.
 // Used only during graceful restarts where a new process is spawned.
-type caddyfileGob struct {
+type corefileGob struct {
 	ListenerFds            map[string]uintptr
-	Caddyfile              Input
+	Corefile               Input
 	OnDemandTLSCertsIssued int32
 }
 
 // IsRestart returns whether this process is, according
 // to env variables, a fork as part of a graceful restart.
 func IsRestart() bool {
-	return os.Getenv("CADDY_RESTART") == "true"
+	return os.Getenv("COREDNS_RESTART") == "true"
 }
 
 // writePidFile writes the process ID to the file at PidFile, if specified.
@@ -83,20 +83,20 @@ func writePidFile() error {
 	return ioutil.WriteFile(PidFile, pid, 0644)
 }
 
-// CaddyfileInput represents a Caddyfile as input
+// CorefileInput represents a Corefile as input
 // and is simply a convenient way to implement
 // the Input interface.
-type CaddyfileInput struct {
+type CorefileInput struct {
 	Filepath string
 	Contents []byte
 	RealFile bool
 }
 
 // Body returns c.Contents.
-func (c CaddyfileInput) Body() []byte { return c.Contents }
+func (c CorefileInput) Body() []byte { return c.Contents }
 
 // Path returns c.Filepath.
-func (c CaddyfileInput) Path() string { return c.Filepath }
+func (c CorefileInput) Path() string { return c.Filepath }
 
 // IsFile returns true if the original input was a real file on the file system.
-func (c CaddyfileInput) IsFile() bool { return c.RealFile }
+func (c CorefileInput) IsFile() bool { return c.RealFile }

core/https/certificates.go

@@ -33,7 +33,7 @@ type Certificate struct {
 	// NotAfter is when the certificate expires.
 	NotAfter time.Time
 
-	// Managed certificates are certificates that Caddy is managing,
+	// Managed certificates are certificates that CoreDNS is managing,
 	// as opposed to the user specifying a certificate and key file
 	// or directory and managing the certificate resources themselves.
 	Managed bool

core/https/handshake.go

@@ -301,7 +301,7 @@ var OnDemandIssuedCount = new(int32)
 // maximum number of certificates that can be issued.
 // TODO: This applies globally, but we should probably make a server-specific
 // way to keep track of these limits and counts, since it's specified in the
-// Caddyfile...
+// Corefile...
 var onDemandMaxIssue int32
 
 // failedIssuance is a set of names that we recently failed to get a

core/https/https.go

@@ -1,5 +1,5 @@
 // Package https facilitates the management of TLS assets and integrates
-// Let's Encrypt functionality into Caddy with first-class support for
+// Let's Encrypt functionality into CoreDNS with first-class support for
 // creating and renewing certificates automatically. It is designed to
 // configure sites for HTTPS by default.
 package https

core/https/user.go

@@ -121,14 +121,14 @@ func newUser(email string) (User, error) {
 // input. If userPresent is false, the operator will
 // NOT be prompted and an empty email may be returned.
 func getEmail(cfg server.Config, userPresent bool) string {
-	// First try the tls directive from the Caddyfile
+	// First try the tls directive from the Corefile
 	leEmail := cfg.TLS.LetsEncryptEmail
 	if leEmail == "" {
 		// Then try memory (command line flag or typed by user previously)
 		leEmail = DefaultEmail
 	}
 	if leEmail == "" {
-		// Then try to get most recent user email ~/.caddy/users file
+		// Then try to get most recent user email ~/.coredns/users file
 		userDirs, err := ioutil.ReadDir(storage.Users())
 		if err == nil {
 			var mostRecent os.FileInfo

core/parse/parsing.go

@@ -55,7 +55,7 @@ func (p *parser) begin() error {
 	}
 
 	if p.eof {
-		// this happens if the Caddyfile consists of only
+		// this happens if the Corefile consists of only
 		// a line of addresses and nothing else
 		return nil
 	}
@@ -91,7 +91,7 @@ func (p *parser) addresses() error {
 			break
 		}
 
-		if tkn != "" { // empty token possible if user typed "" in Caddyfile
+		if tkn != "" { // empty token possible if user typed "" in Corefile
 			// Trailing comma indicates another address will follow, which
 			// may possibly be on the next line
 			if tkn[len(tkn)-1] == ',' {

core/restart.go

@@ -18,32 +18,32 @@ import (
 )
 
 func init() {
-	gob.Register(CaddyfileInput{})
+	gob.Register(CorefileInput{})
 }
 
 // Restart restarts the entire application; gracefully with zero
 // downtime if on a POSIX-compatible system, or forcefully if on
 // Windows but with imperceptibly-short downtime.
 //
-// The restarted application will use newCaddyfile as its input
-// configuration. If newCaddyfile is nil, the current (existing)
-// Caddyfile configuration will be used.
+// The restarted application will use newCorefile as its input
+// configuration. If newCorefile is nil, the current (existing)
+// Corefile configuration will be used.
 //
 // Note: The process must exist in the same place on the disk in
 // order for this to work. Thus, multiple graceful restarts don't
 // work if executing with `go run`, since the binary is cleaned up
 // when `go run` sees the initial parent process exit.
-func Restart(newCaddyfile Input) error {
+func Restart(newCorefile Input) error {
 	log.Println("[INFO] Restarting")
 
-	if newCaddyfile == nil {
-		caddyfileMu.Lock()
-		newCaddyfile = caddyfile
-		caddyfileMu.Unlock()
+	if newCorefile == nil {
+		corefileMu.Lock()
+		newCorefile = corefile
+		corefileMu.Unlock()
 	}
 
-	// Get certificates for any new hosts in the new Caddyfile without causing downtime
-	err := getCertsForNewCaddyfile(newCaddyfile)
+	// Get certificates for any new hosts in the new Corefile without causing downtime
+	err := getCertsForNewCorefile(newCorefile)
 	if err != nil {
 		return errors.New("TLS preload: " + err.Error())
 	}
@@ -53,16 +53,16 @@ func Restart(newCaddyfile Input) error {
 	}
 
 	// Tell the child that it's a restart
-	os.Setenv("CADDY_RESTART", "true")
+	os.Setenv("COREDNS_RESTART", "true")
 
 	// Prepare our payload to the child process
-	cdyfileGob := caddyfileGob{
+	crfileGob := corefileGob{
 		ListenerFds:            make(map[string]uintptr),
-		Caddyfile:              newCaddyfile,
+		Corefile:               newCorefile,
 		OnDemandTLSCertsIssued: atomic.LoadInt32(https.OnDemandIssuedCount),
 	}
 
-	// Prepare a pipe to the fork's stdin so it can get the Caddyfile
+	// Prepare a pipe to the fork's stdin so it can get the Corefile
 	rpipe, wpipe, err := os.Pipe()
 	if err != nil {
 		return err
@@ -83,7 +83,7 @@ func Restart(newCaddyfile Input) error {
 	serversMu.Lock()
 	for i, s := range servers {
 		extraFiles = append(extraFiles, s.ListenerFd())
-		cdyfileGob.ListenerFds[s.Addr] = uintptr(4 + i) // 4 fds come before any of the listeners
+		crfileGob.ListenerFds[s.Addr] = uintptr(4 + i) // 4 fds come before any of the listeners
 	}
 	serversMu.Unlock()
 
@@ -105,8 +105,8 @@ func Restart(newCaddyfile Input) error {
 		f.Close()
 	}
 
-	// Feed Caddyfile to the child
-	err = gob.NewEncoder(wpipe).Encode(cdyfileGob)
+	// Feed Corefile to the child
+	err = gob.NewEncoder(wpipe).Encode(crfileGob)
 	if err != nil {
 		return err
 	}
@@ -127,12 +127,12 @@ func Restart(newCaddyfile Input) error {
 	return Stop()
 }
 
-func getCertsForNewCaddyfile(newCaddyfile Input) error {
-	// parse the new caddyfile only up to (and including) TLS
+func getCertsForNewCorefile(newCorefile Input) error {
+	// parse the new corefile only up to (and including) TLS
 	// so we can know what we need to get certs for.
-	configs, _, _, err := loadConfigsUpToIncludingTLS(path.Base(newCaddyfile.Path()), bytes.NewReader(newCaddyfile.Body()))
+	configs, _, _, err := loadConfigsUpToIncludingTLS(path.Base(newCorefile.Path()), bytes.NewReader(newCorefile.Body()))
 	if err != nil {
-		return errors.New("loading Caddyfile: " + err.Error())
+		return errors.New("loading Corefile: " + err.Error())
 	}
 
 	// first mark the configs that are qualified for managed TLS

core/restart_windows.go

@@ -2,15 +2,15 @@ package core
 
 import "log"
 
-// Restart restarts Caddy forcefully using newCaddyfile,
-// or, if nil, the current/existing Caddyfile is reused.
-func Restart(newCaddyfile Input) error {
+// Restart restarts CoreDNS forcefully using newCorefile,
+// or, if nil, the current/existing Corefile is reused.
+func Restart(newCorefile Input) error {
 	log.Println("[INFO] Restarting")
 
-	if newCaddyfile == nil {
-		caddyfileMu.Lock()
-		newCaddyfile = caddyfile
-		caddyfileMu.Unlock()
+	if newCorefile == nil {
+		corefileMu.Lock()
+		newCorefile = corefile
+		corefileMu.Unlock()
 	}
 
 	wg.Add(1) // barrier so Wait() doesn't unblock
@@ -20,7 +20,7 @@ func Restart(newCaddyfile Input) error {
 		return err
 	}
 
-	err = Start(newCaddyfile)
+	err = Start(newCorefile)
 	if err != nil {
 		return err
 	}

core/setup/log.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/hashicorp/go-syslog"
 	"github.com/miekg/coredns/middleware"
-	caddylog "github.com/miekg/coredns/middleware/log"
+	corednslog "github.com/miekg/coredns/middleware/log"
 	"github.com/miekg/coredns/server"
 	"github.com/miekg/dns"
 )
@@ -30,7 +30,7 @@ func Log(c *Controller) (middleware.Middleware, error) {
 			} else if rules[i].OutputFile == "stderr" {
 				writer = os.Stderr
 			} else if rules[i].OutputFile == "syslog" {
-				writer, err = gsyslog.NewLogger(gsyslog.LOG_INFO, "LOCAL0", "caddy")
+				writer, err = gsyslog.NewLogger(gsyslog.LOG_INFO, "LOCAL0", "coredns")
 				if err != nil {
 					return err
 				}
@@ -56,12 +56,12 @@ func Log(c *Controller) (middleware.Middleware, error) {
 	})
 
 	return func(next middleware.Handler) middleware.Handler {
-		return caddylog.Logger{Next: next, Rules: rules, ErrorFunc: server.DefaultErrorFunc}
+		return corednslog.Logger{Next: next, Rules: rules, ErrorFunc: server.DefaultErrorFunc}
 	}, nil
 }
 
-func logParse(c *Controller) ([]caddylog.Rule, error) {
-	var rules []caddylog.Rule
+func logParse(c *Controller) ([]corednslog.Rule, error) {
+	var rules []corednslog.Rule
 
 	for c.Next() {
 		args := c.RemainingArgs()
@@ -88,37 +88,37 @@ func logParse(c *Controller) ([]caddylog.Rule, error) {
 		}
 		if len(args) == 0 {
 			// Nothing specified; use defaults
-			rules = append(rules, caddylog.Rule{
+			rules = append(rules, corednslog.Rule{
 				NameScope:  ".",
-				OutputFile: caddylog.DefaultLogFilename,
-				Format:     caddylog.DefaultLogFormat,
+				OutputFile: corednslog.DefaultLogFilename,
+				Format:     corednslog.DefaultLogFormat,
 				Roller:     logRoller,
 			})
 		} else if len(args) == 1 {
 			// Only an output file specified
-			rules = append(rules, caddylog.Rule{
+			rules = append(rules, corednslog.Rule{
 				NameScope:  ".",
 				OutputFile: args[0],
-				Format:     caddylog.DefaultLogFormat,
+				Format:     corednslog.DefaultLogFormat,
 				Roller:     logRoller,
 			})
 		} else {
 			// Name scope, output file, and maybe a format specified
 
-			format := caddylog.DefaultLogFormat
+			format := corednslog.DefaultLogFormat
 
 			if len(args) > 2 {
 				switch args[2] {
 				case "{common}":
-					format = caddylog.CommonLogFormat
+					format = corednslog.CommonLogFormat
 				case "{combined}":
-					format = caddylog.CombinedLogFormat
+					format = corednslog.CombinedLogFormat
 				default:
 					format = args[2]
 				}
 			}
 
-			rules = append(rules, caddylog.Rule{
+			rules = append(rules, corednslog.Rule{
 				NameScope:  dns.Fqdn(args[0]),
 				OutputFile: args[1],
 				Format:     format,

core/sigtrap_posix.go

@@ -48,28 +48,28 @@ func trapSignalsPosix() {
 			case syscall.SIGUSR1:
 				log.Println("[INFO] SIGUSR1: Reloading")
 
-				var updatedCaddyfile Input
+				var updatedCorefile Input
 
-				caddyfileMu.Lock()
-				if caddyfile == nil {
+				corefileMu.Lock()
+				if corefile == nil {
 					// Hmm, did spawing process forget to close stdin? Anyhow, this is unusual.
 					log.Println("[ERROR] SIGUSR1: no Corefile to reload (was stdin left open?)")
-					caddyfileMu.Unlock()
+					corefileMu.Unlock()
 					continue
 				}
-				if caddyfile.IsFile() {
-					body, err := ioutil.ReadFile(caddyfile.Path())
+				if corefile.IsFile() {
+					body, err := ioutil.ReadFile(corefile.Path())
 					if err == nil {
-						updatedCaddyfile = CaddyfileInput{
-							Filepath: caddyfile.Path(),
+						updatedCorefile = CorefileInput{
+							Filepath: corefile.Path(),
 							Contents: body,
 							RealFile: true,
 						}
 					}
 				}
-				caddyfileMu.Unlock()
+				corefileMu.Unlock()
 
-				err := Restart(updatedCaddyfile)
+				err := Restart(updatedCorefile)
 				if err != nil {
 					log.Printf("[ERROR] SIGUSR1: %v", err)
 				}