在 caddy.go 中定義著 Server 的介面，同時實現了優雅的退出。我們首先看圖瞭解組織結構
簡單看一下 Stopper 的介面
// Stopper is a type that can stop serving. The stop// does not necessarily have to be graceful.type Stopper interface {
// Stop stops the server. It blocks until the// server is completely stopped.
Stop() error
}
複製程式碼
GracefulServer 包含 Stopper 的介面實現了優雅退出，這是攔截了 系統 signal 的訊號之後執行的結果，意在意外中斷的時候儲存好需要儲存的東西。
它同時包含著 WrapListener 函式。可以看出，他用來做中介軟體。
// WrapListener wraps a listener with the// listener middlewares configured for this// server,if any.
WrapListener(net.Listener) net.Listener
複製程式碼
ServerType
最後看到不同 serverType 生成不同的 server
另外可以看到 這裡最重要的 Instance 下面我們進一步檢視 Instance 的程式碼
Instance
instance 是 Server 用來執行操作的實體。首先來看他的結構。它的程式碼在 主資料夾中的 caddy.go 中
type EventHook func(eventType EventName,eventInfo interface{})error複製程式碼
然後我們關注到如何註冊，和圖中的 caddy.EmitEvent
註冊與分發
註冊 EventHook
可以看到使用 eventHooks.LoadOrStore方法，不必贅述
funcRegisterEventHook(name string,hook EventHook){
if name == "" {
panic("event hook must have a name")
}
_,dup := eventHooks.LoadOrStore(name,hook)
if dup {
panic("hook named" + name + "already registered")
}
}
複製程式碼
// EmitEvent executes the different hooks passing the EventType as an// argument. This is a blocking function. Hook developers should// use 'go' keyword if they don't want to block Caddy.funcEmitEvent(event EventName,info interface{}) {
eventHooks.Range(func(k,v interface{})bool {
err := v.(EventHook)(event,info)
if err != nil {
log.Printf("error on '%s' hook: %v",k.(string),err)
}
returntrue//注意這裡返回的是 true
})
}
複製程式碼
這裡使用的 Range 函式，實際上是把事件資訊給每一個上述提過 map 中的 EventHook 提供引數進行回撥執行，按順序呼叫，但是如果 傳入函式返回 false ，迭代遍歷執行就會中斷。
// allTokens lexes the entire input,but does not parse it.// It returns all the tokens from the input,unstructured// and in order.funcallTokens(input io.Reader)([]Token,error) {
l := new(lexer)
err := l.load(input)
if err != nil {
returnnil,err
}
var tokens []Token
for l.next() {
tokens = append(tokens,l.token)
}
return tokens,nil
}
複製程式碼
// next loads the next token into the lexer.
// A token is delimited by whitespace,unless
// the token starts with a quotes character (")
// in which case the token goes until the closing
// quotes (the enclosing quotes are not included).
// Inside quoted strings,quotes may be escaped
// with a preceding \ character. No other chars
// may be escaped. The rest of the line is skipped
// if a "#" character is read in. Returns true if
// a token was loaded; false otherwise.
func (l *lexer) next() bool {
var val []rune
var comment,quoted,escaped bool
makeToken := func() bool {
l.token.Text = string(val)
return true
}
for {
ch,_,err := l.reader.ReadRune()
if err != nil {
if len(val) > 0 {
return makeToken()
}
if err == io.EOF {
return false
}
panic(err)
}
if quoted {
if !escaped {
if ch == '\\' {
escaped = true
continue
} else if ch == '"' {
quoted = false
return makeToken()
}
}
if ch == '\n' {
l.line++
}
if escaped {
// only escape quotes
if ch != '"' {
val = append(val,'\\')
}
}
val = append(val,ch)
escaped = false
continue
}
if unicode.IsSpace(ch) {
if ch == '\r' {
continue
}
if ch == '\n' {
l.line++
comment = false
}
if len(val) > 0 {
return makeToken()
}
continue
}
if ch == '#' {
comment = true
}
if comment {
continue
}
if len(val) == 0 {
l.token = Token{Line: l.line}
if ch == '"' {
quoted = true
continue
}
}
val = append(val,ch)
}
}
複製程式碼
理解了 next 函式，就很容易知道如何分析一塊選項的 token 了，不過都是 next() 的包裝函式罷了。
funcexecuteDirectives(inst *Instance,filename string,directives []string,sblocks []caddyfile.ServerBlock,justValidate bool)error {
// map of server block ID to map of directive name to whatever.
storages := make(map[int]map[string]interface{})
// It is crucial that directives are executed in the proper order.// We loop with the directives on the outer loop so we execute// a directive for all server blocks before going to the next directive.// This is important mainly due to the parsing callbacks (below).for _,dir := range directives {
for i,sb := range sblocks {
var once sync.Once
if _,ok := storages[i]; !ok {
storages[i] = make(map[string]interface{})
}
for j,key := range sb.Keys {
// Execute directive if it is in the server blockif tokens,ok := sb.Tokens[dir]; ok {
controller := &Controller{
instance: inst,Key: key,Dispenser: caddyfile.NewDispenserTokens(filename,tokens),OncePerServerBlock: func(f func()error) error {
var err error
once.Do(func() {
err = f()
})
return err
},ServerBlockIndex: i,ServerBlockKeyIndex: j,ServerBlockKeys: sb.Keys,ServerBlockStorage: storages[i][dir],}
setup,err := DirectiveAction(inst.serverType,dir)
if err != nil {
return err
}
err = setup(controller)
if err != nil {
return err
}
storages[i][dir] = controller.ServerBlockStorage // persist for this server block
}
}
}
if !justValidate {
// See if there are any callbacks to execute after this directiveif allCallbacks,ok := parsingCallbacks[inst.serverType]; ok {
callbacks := allCallbacks[dir]
for _,callback := range callbacks {
if err := callback(inst.context); err != nil {
return err
}
}
}
}
}
returnnil
}
複製程式碼
// DirectiveAction gets the action for directive dir of// server type serverType.funcDirectiveAction(serverType,dir string)(SetupFunc,error) {
if stypePlugins,ok := plugins[serverType]; ok {
if plugin,ok := stypePlugins[dir]; ok {
return plugin.Action,nil
}
}
if genericPlugins,ok := plugins[""]; ok {
if plugin,ok := genericPlugins[dir]; ok {
return plugin.Action,nil
}
}
returnnil,fmt.Errorf("no action found for directive '%s' with server type '%s' (missing a plugin?)",dir,serverType)
}
複製程式碼
// ErrorHandler handles HTTP errors (and errors from other middleware).type ErrorHandler struct {
Next httpserver.Handler
GenericErrorPage string// default error page filename
ErrorPages map[int]string// map of status code to filename
Log *httpserver.Logger
Debug bool// if true,errors are written out to client rather than to a log
}
複製程式碼
