d04abdf422
* Laying down kubernetes middleware foundation * Duplicated a bunch of code form etcd middleware * Duplicated code hacked to compile and load as a separate middleware * Adding verbose build option to Makefile * Removing stubzone and tls support tls and stubzone support was carried over from base etcd middleware code. Removing to simplify the kube middleware implementation. (For now.) * Adding conf directory for sample conf files * Removing stubzone support from query handler * Remove upstream and proxy from k8s corefile. Not sure that upstream or proxy makes sense for a k8s backed zone. * Comment out use of singleflight serialization * Removing parsing support for "upstream" directive from k8s * Removing upstream directive parsing code * Removing CNAME and TXT lookup implementation * Create README.md Brain-dump of DNS record name assembly and open work items. * Adding notes about wildcard handling * Adding basic k8s API client * Fleshing out methods on k8s connector * Remove PathPrefix from middleware init * Removing incorrect plural * Adding brute-force k8s service lookup functions * Initializing k8s API connector during startup * Hacking around to call k8s connector * Parsing incoming domain name into serviceName and namespace * Improving and simplifying k8s zone matching and label segmentation * Removing unused functions carried over from etcd middleware * Adding basic return of k8s data to DNS client * updated debugging println statements to flag with "[debug]" * removed code in kubernetes.go::Records that was a hold-over from etcd middleware. * Removed some random exploratory hacking. * Minior README.md updates * Updating with demo instructions * Updating README.md with CoreFile and removing completed TODO items * Updating conf file and README to reflect DNS response cache works * Disabling DNS response caching * Adding debug statement on entry to Records() * Changing port number in exampes to port 53. * Misc style and clarity changes * Removing empty function definitions * Adding comment to track future cleanup * Refactoring README to follow style of other middleware * Exposing dataobject field (typo)
98 lines
3.2 KiB
Go
98 lines
3.2 KiB
Go
package core
|
|
|
|
import (
|
|
"github.com/miekg/coredns/core/https"
|
|
"github.com/miekg/coredns/core/parse"
|
|
"github.com/miekg/coredns/core/setup"
|
|
"github.com/miekg/coredns/middleware"
|
|
)
|
|
|
|
func init() {
|
|
// The parse package must know which directives
|
|
// are valid, but it must not import the setup
|
|
// or config package. To solve this problem, we
|
|
// fill up this map in our init function here.
|
|
// The parse package does not need to know the
|
|
// ordering of the directives.
|
|
for _, dir := range directiveOrder {
|
|
parse.ValidDirectives[dir.name] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// Directives are registered in the order they should be
|
|
// executed. Middleware (directives that inject a handler)
|
|
// are executed in the order A-B-C-*-C-B-A, assuming
|
|
// they all call the Next handler in the chain.
|
|
//
|
|
// Ordering is VERY important. Every middleware will
|
|
// feel the effects of all other middleware below
|
|
// (after) them during a request, but they must not
|
|
// care what middleware above them are doing.
|
|
//
|
|
// For example, log needs to know the status code and
|
|
// exactly how many bytes were written to the client,
|
|
// which every other middleware can affect, so it gets
|
|
// registered first. The errors middleware does not
|
|
// care if gzip or log modifies its response, so it
|
|
// gets registered below them. Gzip, on the other hand,
|
|
// DOES care what errors does to the response since it
|
|
// must compress every output to the client, even error
|
|
// pages, so it must be registered before the errors
|
|
// middleware and any others that would write to the
|
|
// response.
|
|
var directiveOrder = []directive{
|
|
// Essential directives that initialize vital configuration settings
|
|
{"root", setup.Root},
|
|
{"bind", setup.BindHost},
|
|
{"tls", https.Setup},
|
|
{"health", setup.Health},
|
|
{"pprof", setup.PProf},
|
|
|
|
// Other directives that don't create HTTP handlers
|
|
{"startup", setup.Startup},
|
|
{"shutdown", setup.Shutdown},
|
|
|
|
// Directives that inject handlers (middleware)
|
|
{"prometheus", setup.Prometheus},
|
|
{"errors", setup.Errors},
|
|
{"log", setup.Log},
|
|
|
|
{"chaos", setup.Chaos},
|
|
{"rewrite", setup.Rewrite},
|
|
{"loadbalance", setup.Loadbalance},
|
|
{"cache", setup.Cache},
|
|
{"dnssec", setup.Dnssec},
|
|
{"file", setup.File},
|
|
{"secondary", setup.Secondary},
|
|
{"etcd", setup.Etcd},
|
|
{"kubernetes", setup.Kubernetes},
|
|
{"proxy", setup.Proxy},
|
|
}
|
|
|
|
// 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) {
|
|
dir := directive{name: name, setup: setup}
|
|
idx := len(directiveOrder)
|
|
for i := range directiveOrder {
|
|
if directiveOrder[i].name == after {
|
|
idx = i + 1
|
|
break
|
|
}
|
|
}
|
|
newDirectives := append(directiveOrder[:idx], append([]directive{dir}, directiveOrder[idx:]...)...)
|
|
directiveOrder = newDirectives
|
|
parse.ValidDirectives[name] = struct{}{}
|
|
}
|
|
|
|
// directive ties together a directive name with its setup function.
|
|
type directive struct {
|
|
name string
|
|
setup SetupFunc
|
|
}
|
|
|
|
// SetupFunc takes a controller and may optionally return a middleware.
|
|
// If the resulting middleware is not nil, it will be chained into
|
|
// the DNS handlers in the order specified in this package.
|
|
type SetupFunc func(c *setup.Controller) (middleware.Middleware, error)
|