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

Makefile

@@ -5,3 +5,15 @@ all:
 docker:
 	GOOS=linux go build -a -tags netgo -installsuffix netgo
 	docker build -t $$USER/coredns .
+
+.PHONY: deps
+deps:
+	go get
+
+.PHONY: test
+test:
+	go test
+
+.PHONY: clean
+clean:
+	go clean

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

-// 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

 // 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)
 				}

main.go

@@ -84,13 +84,13 @@ func main() {
 	}
 
 	// Get Corefile input
-	caddyfile, err := core.LoadCaddyfile(loadCaddyfile)
+	corefile, err := core.LoadCorefile(loadCorefile)
 	if err != nil {
 		mustLogFatal(err)
 	}
 
 	// Start your engines
-	err = core.Start(caddyfile)
+	err = core.Start(corefile)
 	if err != nil {
 		mustLogFatal(err)
 	}
@@ -112,11 +112,11 @@ func mustLogFatal(args ...interface{}) {
 	log.Fatal(args...)
 }
 
-func loadCaddyfile() (core.Input, error) {
+func loadCorefile() (core.Input, error) {
 	// Try -conf flag
 	if conf != "" {
 		if conf == "stdin" {
-			return core.CaddyfileFromPipe(os.Stdin)
+			return core.CorefileFromPipe(os.Stdin)
 		}
 
 		contents, err := ioutil.ReadFile(conf)
@@ -124,7 +124,7 @@ func loadCaddyfile() (core.Input, error) {
 			return nil, err
 		}
 
-		return core.CaddyfileInput{
+		return core.CorefileInput{
 			Contents: contents,
 			Filepath: conf,
 			RealFile: true,
@@ -134,13 +134,13 @@ func loadCaddyfile() (core.Input, error) {
 	// command line args
 	if flag.NArg() > 0 {
 		confBody := core.Host + ":" + core.Port + "\n" + strings.Join(flag.Args(), "\n")
-		return core.CaddyfileInput{
+		return core.CorefileInput{
 			Contents: []byte(confBody),
 			Filepath: "args",
 		}, nil
 	}
 
-	// Caddyfile in cwd
+	// Corefile in cwd
 	contents, err := ioutil.ReadFile(core.DefaultConfigFile)
 	if err != nil {
 		if os.IsNotExist(err) {
@@ -148,7 +148,7 @@ func loadCaddyfile() (core.Input, error) {
 		}
 		return nil, err
 	}
-	return core.CaddyfileInput{
+	return core.CorefileInput{
 		Contents: contents,
 		Filepath: core.DefaultConfigFile,
 		RealFile: true,

middleware/file/file_test.go

@@ -12,12 +12,12 @@ func BenchmarkParseInsert(b *testing.B) {
 }
 
 /*
-var testDir = filepath.Join(os.TempDir(), "caddy_testdir")
+var testDir = filepath.Join(os.TempDir(), "coredns_testdir")
 var ErrCustom = errors.New("Custom Error")
 
 // testFiles is a map with relative paths to test files as keys and file content as values.
 // The map represents the following structure:
-// - $TEMP/caddy_testdir/
+// - $TEMP/coredns_testdir/
 // '-- file1.html
 // '-- dirwithindex/
 // '---- index.html

middleware/proxy/README.md

@@ -31,7 +31,7 @@ proxy from to... {
 * `from` is the base path to match for the request to be proxied.
 * `to` is the destination endpoint to proxy to. At least one is required, but multiple may be specified.
 * `policy` is the load balancing policy to use; applies only with multiple backends. May be one of random, least_conn, or round_robin. Default is random.
-* `fail_timeout` specifies how long to consider a backend as down after it has failed. While it is down, requests will not be routed to that backend. A backend is "down" if Caddy fails to communicate with it. The default value is 10 seconds ("10s").
+* `fail_timeout` specifies how long to consider a backend as down after it has failed. While it is down, requests will not be routed to that backend. A backend is "down" if CoreDNS fails to communicate with it. The default value is 10 seconds ("10s").
 * `max_fails` is the number of failures within fail_timeout that are needed before considering a backend to be down. If 0, the backend will never be marked as down. Default is 1.
 * `health_check` will check path (on port) on each backend. If a backend returns a status code of 200-399, then that backend is healthy. If it doesn't, the backend is marked as unhealthy for duration and no requests are routed to it. If this option is not provided then health checks are disabled. The default duration is 10 seconds ("10s").
 * `ignored_names...` is a space-separated list of paths to exclude from proxying. Requests that match any of these paths will be passed thru.