APIInstaller

APIInstaller是对APIGroupVersion的封装，定义在/pkg/apiserver/api_installer.go：

1
2
3
4
5
type APIInstaller struct {
	group             *APIGroupVersion
	prefix            string // Path prefix where API resources are to be registered.
	minRequestTimeout time.Duration
}

APIInstaller的prefix为Root+GroupVersion.Group+GroupVersion.Version，主要有：/api/v1, /apis/apps/v1beta1, /apis/authentication.k8s.io/v1beta1, /apis/authorization.k8s.io/v1beta1, /apis/autoscaling/v1, /apis/batch/v1, /apis/batch/v2alpha1, /apis/certificates.k8s.io/v1alpha1, /apis/extensions/v1beta1, /apis/policy/v1beta1, /apis/rbac.authorization.k8s.io/v1alpha1, /apis/storage.k8s.io/v1beta1。

APIInstaller.Install()

APIInstaller最重要的成员就是Install()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Installs handlers for API resources.
func (a *APIInstaller) Install(ws *restful.WebService) (apiResources []unversioned.APIResource, errors []error) {
	errors = make([]error, 0)
	proxyHandler := (&ProxyHandler{
		prefix:     a.prefix + "/proxy/",
		storage:    a.group.Storage,
		serializer: a.group.Serializer,
		mapper:     a.group.Context,
	})
	// Register the paths in a deterministic (sorted) order to get a deterministic swagger spec.
	paths := make([]string, len(a.group.Storage))
	var i int = 0
	//***path: deployments, replicasets/status***//
	for path := range a.group.Storage {
		paths[i] = path
		i++
	}
	sort.Strings(paths)
	for _, path := range paths {
		//***apiResource: &APIResource{Name:horizontalpodautoscalers/status,Namespaced:true,Kind:HorizontalPodAutoscaler,}***//
		//***注册路由***//
		apiResource, err := a.registerResourceHandlers(path, a.group.Storage[path], ws, proxyHandler)
		if err != nil {
			errors = append(errors, fmt.Errorf("error in registering resource: %s, %v", path, err))
		}
		if apiResource != nil {
			apiResources = append(apiResources, *apiResource)
		}
	}
	return apiResources, errors
}

在Install()中，先把GroupAPIVersion中的Stoage中的路径构建成paths数组，然后轮询paths，通过registerResourceHandlers()注册路由。

registerResourceHandlers

registerResourceHandlers()函数很长，将分段分析。

1 首先分离出resource和subresource

1
2
3
4
resource, subresource, err := splitSubresource(path)
if err != nil {
	return nil, err
}

splitSubresource()函数定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//***通过'/'分割出resource和subresource***//
func splitSubresource(path string) (string, string, error) {
	var resource, subresource string
	switch parts := strings.Split(path, "/"); len(parts) {
	case 2:
		resource, subresource = parts[0], parts[1]
	case 1:
		resource = parts[0]
	default:
		// TODO: support deeper paths
		return "", "", fmt.Errorf("api_installer allows only one or two segment paths (resource or resource/subresource)")
	}
	return resource, subresource, nil
}

2 获取该resource对应的mapping

1
2
3
4
mapping, err := a.restMapping(resource)
if err != nil {
	return nil, err
}

restMapping()定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
func (a *APIInstaller) restMapping(resource string) (*meta.RESTMapping, error) {
	// subresources must have parent resources, and follow the namespacing rules of their parent.
	// So get the storage of the resource (which is the parent resource in case of subresources)
	storage, ok := a.group.Storage[resource]
	if !ok {
		return nil, fmt.Errorf("unable to locate the storage object for resource: %s", resource)
	}
	fqKindToRegister, err := a.getResourceKind(resource, storage)
	if err != nil {
		return nil, fmt.Errorf("unable to locate fully qualified kind for mapper resource %s: %v", resource, err)
	}
	return a.group.Mapper.RESTMapping(fqKindToRegister.GroupKind(), fqKindToRegister.Version)
}

其中Mapper定义在GroupAPIVersion中。Mapper中存储有GVR和GVK的关系，可以生成Mapping，Mapping中有resource, GVK, Scope, Convertor等与该资源相关的信息。

3 根据storage的实现是否满足具体的interface来判断是否支持某动作，并生成动作执行器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
creater, isCreater := storage.(rest.Creater)
namedCreater, isNamedCreater := storage.(rest.NamedCreater)
lister, isLister := storage.(rest.Lister)
getter, isGetter := storage.(rest.Getter)
getterWithOptions, isGetterWithOptions := storage.(rest.GetterWithOptions)
deleter, isDeleter := storage.(rest.Deleter)
gracefulDeleter, isGracefulDeleter := storage.(rest.GracefulDeleter)
collectionDeleter, isCollectionDeleter := storage.(rest.CollectionDeleter)
updater, isUpdater := storage.(rest.Updater)
patcher, isPatcher := storage.(rest.Patcher)
watcher, isWatcher := storage.(rest.Watcher)
_, isRedirector := storage.(rest.Redirector)
connecter, isConnecter := storage.(rest.Connecter)
storageMeta, isMetadata := storage.(rest.StorageMetadata)
if !isMetadata {
	storageMeta = defaultStorageMetadata{}
}
exporter, isExporter := storage.(rest.Exporter)
if !isExporter {
	exporter = nil
}
versionedExportOptions, err := a.group.Creater.New(optionsExternalVersion.WithKind("ExportOptions"))
if err != nil {
	return nil, err
}
if isNamedCreater {
	isCreater = true
}
var versionedList interface{}
if isLister {
	list := lister.NewList()
	listGVKs, _, err := a.group.Typer.ObjectKinds(list)
	if err != nil {
		return nil, err
	}
	versionedListPtr, err := a.group.Creater.New(a.group.GroupVersion.WithKind(listGVKs[0].Kind))
	if err != nil {
		return nil, err
	}
	versionedList = indirectArbitraryPointer(versionedListPtr)
}
versionedListOptions, err := a.group.Creater.New(optionsExternalVersion.WithKind("ListOptions"))
if err != nil {
	return nil, err
}
var versionedDeleteOptions runtime.Object
var versionedDeleterObject interface{}
switch {
case isGracefulDeleter:
	versionedDeleteOptions, err = a.group.Creater.New(optionsExternalVersion.WithKind("DeleteOptions"))
	if err != nil {
		return nil, err
	}
	versionedDeleterObject = indirectArbitraryPointer(versionedDeleteOptions)
	isDeleter = true
case isDeleter:
	gracefulDeleter = rest.GracefulDeleteAdapter{Deleter: deleter}
}
versionedStatusPtr, err := a.group.Creater.New(optionsExternalVersion.WithKind("Status"))
if err != nil {
	return nil, err
}
versionedStatus := indirectArbitraryPointer(versionedStatusPtr)
var (
	getOptions             runtime.Object
	versionedGetOptions    runtime.Object
	getOptionsInternalKind unversioned.GroupVersionKind
	getSubpath             bool
)
if isGetterWithOptions {
	getOptions, getSubpath, _ = getterWithOptions.NewGetOptions()
	getOptionsInternalKinds, _, err := a.group.Typer.ObjectKinds(getOptions)
	if err != nil {
		return nil, err
	}
	getOptionsInternalKind = getOptionsInternalKinds[0]
	versionedGetOptions, err = a.group.Creater.New(optionsExternalVersion.WithKind(getOptionsInternalKind.Kind))
	if err != nil {
		return nil, err
	}
	isGetter = true
}
var versionedWatchEvent interface{}
if isWatcher {
	versionedWatchEventPtr, err := a.group.Creater.New(a.group.GroupVersion.WithKind("WatchEvent"))
	if err != nil {
		return nil, err
	}
	versionedWatchEvent = indirectArbitraryPointer(versionedWatchEventPtr)
}
var (
	connectOptions             runtime.Object
	versionedConnectOptions    runtime.Object
	connectOptionsInternalKind unversioned.GroupVersionKind
	connectSubpath             bool
)
if isConnecter {
	connectOptions, connectSubpath, _ = connecter.NewConnectOptions()
	if connectOptions != nil {
		connectOptionsInternalKinds, _, err := a.group.Typer.ObjectKinds(connectOptions)
		if err != nil {
			return nil, err
		}
		connectOptionsInternalKind = connectOptionsInternalKinds[0]
		versionedConnectOptions, err = a.group.Creater.New(optionsExternalVersion.WithKind(connectOptionsInternalKind.Kind))
		if err != nil {
			return nil, err
		}
	}
}

4 获取scope，依据scope构造actions。action中包含动作，路径等信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
scope := mapping.Scope
nameParam := ws.PathParameter("name", "name of the "+kind).DataType("string")
pathParam := ws.PathParameter("path", "path to the resource").DataType("string")
params := []*restful.Parameter{}
actions := []action{}
var resourceKind string
kindProvider, ok := storage.(rest.KindProvider)
if ok {
	resourceKind = kindProvider.Kind()
} else {
	resourceKind = kind
}
var apiResource unversioned.APIResource
// Get the list of actions for the given scope.
switch scope.Name() {
//***scope为RESSTScopeNameRoot***//
//***resourcePath: persistentvolumes***//
//***itemPath: persistentvolumes/{name}***//
case meta.RESTScopeNameRoot:
	// Handle non-namespace scoped resources like nodes.
	resourcePath := resource
	resourceParams := params
	itemPath := resourcePath + "/{name}"
	nameParams := append(params, nameParam)
	proxyParams := append(nameParams, pathParam)
	suffix := ""
	if hasSubresource {
		suffix = "/" + subresource
		itemPath = itemPath + suffix
		resourcePath = itemPath
		resourceParams = nameParams
	}
	apiResource.Name = path
	apiResource.Namespaced = false
	apiResource.Kind = resourceKind
	namer := rootScopeNaming{scope, a.group.Linker, gpath.Join(a.prefix, resourcePath, "/"), suffix}
	// Handler for standard REST verbs (GET, PUT, POST and DELETE).
	// Add actions at the resource path: /api/apiVersion/resource
	actions = appendIf(actions, action{"LIST", resourcePath, resourceParams, namer, false}, isLister)
	actions = appendIf(actions, action{"POST", resourcePath, resourceParams, namer, false}, isCreater)
	actions = appendIf(actions, action{"DELETECOLLECTION", resourcePath, resourceParams, namer, false}, isCollectionDeleter)
	// DEPRECATED
	actions = appendIf(actions, action{"WATCHLIST", "watch/" + resourcePath, resourceParams, namer, false}, allowWatchList)
	// Add actions at the item path: /api/apiVersion/resource/{name}
	actions = appendIf(actions, action{"GET", itemPath, nameParams, namer, false}, isGetter)
	if getSubpath {
		actions = appendIf(actions, action{"GET", itemPath + "/{path:*}", proxyParams, namer, false}, isGetter)
	}
	actions = appendIf(actions, action{"PUT", itemPath, nameParams, namer, false}, isUpdater)
	actions = appendIf(actions, action{"PATCH", itemPath, nameParams, namer, false}, isPatcher)
	actions = appendIf(actions, action{"DELETE", itemPath, nameParams, namer, false}, isDeleter)
	actions = appendIf(actions, action{"WATCH", "watch/" + itemPath, nameParams, namer, false}, isWatcher)
	// We add "proxy" subresource to remove the need for the generic top level prefix proxy.
	// The generic top level prefix proxy is deprecated in v1.2, and will be removed in 1.3, or 1.4 at the latest.
	// TODO: DEPRECATED in v1.2.
	actions = appendIf(actions, action{"PROXY", "proxy/" + itemPath + "/{path:*}", proxyParams, namer, false}, isRedirector)
	// TODO: DEPRECATED in v1.2.
	actions = appendIf(actions, action{"PROXY", "proxy/" + itemPath, nameParams, namer, false}, isRedirector)
	actions = appendIf(actions, action{"CONNECT", itemPath, nameParams, namer, false}, isConnecter)
	actions = appendIf(actions, action{"CONNECT", itemPath + "/{path:*}", proxyParams, namer, false}, isConnecter && connectSubpath)
	break
//***如果Scope为RESTScopeNameNamespace***//
//***resourcePath: namespaces/{namespace}/pods***//
//***itemPath: namespaces/{namespace}/pods/{name}***//
case meta.RESTScopeNameNamespace:
	// Handler for standard REST verbs (GET, PUT, POST and DELETE).
	namespaceParam := ws.PathParameter(scope.ArgumentName(), scope.ParamDescription()).DataType("string")
	//***scope.ParamName()返回的是"namespaces"***//
	//***scope.ArgumentName()返回的是"namespace"***//
	namespacedPath := scope.ParamName() + "/{" + scope.ArgumentName() + "}/" + resource
	namespaceParams := []*restful.Parameter{namespaceParam}
	resourcePath := namespacedPath
	resourceParams := namespaceParams
	itemPathPrefix := gpath.Join(a.prefix, scope.ParamName()) + "/"
	itemPath := namespacedPath + "/{name}"
	itemPathMiddle := "/" + resource + "/"
	nameParams := append(namespaceParams, nameParam)
	proxyParams := append(nameParams, pathParam)
	itemPathSuffix := ""
	if hasSubresource {
		itemPathSuffix = "/" + subresource
		itemPath = itemPath + itemPathSuffix
		resourcePath = itemPath
		resourceParams = nameParams
	}
	apiResource.Name = path
	apiResource.Namespaced = true
	apiResource.Kind = resourceKind
	itemPathFn := func(name, namespace string) bytes.Buffer {
		var buf bytes.Buffer
		buf.WriteString(itemPathPrefix)
		buf.WriteString(url.QueryEscape(namespace))
		buf.WriteString(itemPathMiddle)
		buf.WriteString(url.QueryEscape(name))
		buf.WriteString(itemPathSuffix)
		return buf
	}
	namer := scopeNaming{scope, a.group.Linker, itemPathFn, false}
	actions = appendIf(actions, action{"LIST", resourcePath, resourceParams, namer, false}, isLister)
	actions = appendIf(actions, action{"POST", resourcePath, resourceParams, namer, false}, isCreater)
	actions = appendIf(actions, action{"DELETECOLLECTION", resourcePath, resourceParams, namer, false}, isCollectionDeleter)
	// DEPRECATED
	actions = appendIf(actions, action{"WATCHLIST", "watch/" + resourcePath, resourceParams, namer, false}, allowWatchList)
	actions = appendIf(actions, action{"GET", itemPath, nameParams, namer, false}, isGetter)
	if getSubpath {
		actions = appendIf(actions, action{"GET", itemPath + "/{path:*}", proxyParams, namer, false}, isGetter)
	}
	actions = appendIf(actions, action{"PUT", itemPath, nameParams, namer, false}, isUpdater)
	actions = appendIf(actions, action{"PATCH", itemPath, nameParams, namer, false}, isPatcher)
	actions = appendIf(actions, action{"DELETE", itemPath, nameParams, namer, false}, isDeleter)
	actions = appendIf(actions, action{"WATCH", "watch/" + itemPath, nameParams, namer, false}, isWatcher)
	// We add "proxy" subresource to remove the need for the generic top level prefix proxy.
	// The generic top level prefix proxy is deprecated in v1.2, and will be removed in 1.3, or 1.4 at the latest.
	// TODO: DEPRECATED in v1.2.
	actions = appendIf(actions, action{"PROXY", "proxy/" + itemPath + "/{path:*}", proxyParams, namer, false}, isRedirector)
	// TODO: DEPRECATED in v1.2.
	actions = appendIf(actions, action{"PROXY", "proxy/" + itemPath, nameParams, namer, false}, isRedirector)
	actions = appendIf(actions, action{"CONNECT", itemPath, nameParams, namer, false}, isConnecter)
	actions = appendIf(actions, action{"CONNECT", itemPath + "/{path:*}", proxyParams, namer, false}, isConnecter && connectSubpath)
	// list or post across namespace.
	// For ex: LIST all pods in all namespaces by sending a LIST request at /api/apiVersion/pods.
	// TODO: more strongly type whether a resource allows these actions on "all namespaces" (bulk delete)
	if !hasSubresource {
		namer = scopeNaming{scope, a.group.Linker, itemPathFn, true}
		//***LIST操作的Path直接为resource***//
		actions = appendIf(actions, action{"LIST", resource, params, namer, true}, isLister)
		actions = appendIf(actions, action{"WATCHLIST", "watch/" + resource, params, namer, true}, allowWatchList)
	}
	break
default:
	return nil, fmt.Errorf("unsupported restscope: %s", scope.Name())
}

5 处理actions，依据action的动作分别处理

Go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
	for _, action := range actions {
	versionedObject := storageMeta.ProducesObject(action.Verb)
	if versionedObject == nil {
		versionedObject = defaultVersionedObject
	}
	reqScope.Namer = action.Namer
	namespaced := ""
	if apiResource.Namespaced {
		namespaced = "Namespaced"
	}
	operationSuffix := ""
	if strings.HasSuffix(action.Path, "/{path:*}") {
		operationSuffix = operationSuffix + "WithPath"
	}
	//***Fankang***//
	//***此处有个AllNamespaces的概念***//
	if action.AllNamespaces {
		operationSuffix = operationSuffix + "ForAllNamespaces"
		//***Fankang***//
		//***如果AllNamespaces为true，则把namespaced置为空***//
		namespaced = ""
	}
	switch action.Verb {
	case "GET": // Get a resource.
		var handler restful.RouteFunction
		if isGetterWithOptions {
			handler = GetResourceWithOptions(getterWithOptions, reqScope)
		} else {
			handler = GetResource(getter, exporter, reqScope)
		}
		handler = metrics.InstrumentRouteFunc(action.Verb, resource, handler)
		doc := "read the specified " + kind
		if hasSubresource {
			doc = "read " + subresource + " of the specified " + kind
		}
		route := ws.GET(action.Path).To(handler).
			Doc(doc).
			Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
			Operation("read"+namespaced+kind+strings.Title(subresource)+operationSuffix).
			Produces(append(storageMeta.ProducesMIMETypes(action.Verb), mediaTypes...)...).
			Returns(http.StatusOK, "OK", versionedObject).
			Writes(versionedObject)
		if isGetterWithOptions {
			if err := addObjectParams(ws, route, versionedGetOptions); err != nil {
				return nil, err
			}
		}
		if isExporter {
			if err := addObjectParams(ws, route, versionedExportOptions); err != nil {
				return nil, err
			}
		}
		addParams(route, action.Params)
		ws.Route(route)
	case "LIST": // List all resources of a kind.
		doc := "list objects of kind " + kind
		if hasSubresource {
			doc = "list " + subresource + " of objects of kind " + kind
		}
		handler := metrics.InstrumentRouteFunc(action.Verb, resource, ListResource(lister, watcher, reqScope, false, a.minRequestTimeout))
		route := ws.GET(action.Path).To(handler).
			Doc(doc).
			Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
			Operation("list"+namespaced+kind+strings.Title(subresource)+operationSuffix).
			Produces(append(storageMeta.ProducesMIMETypes(action.Verb), allMediaTypes...)...).
			Returns(http.StatusOK, "OK", versionedList).
			Writes(versionedList)
		if err := addObjectParams(ws, route, versionedListOptions); err != nil {
			return nil, err
		}
		switch {
		case isLister && isWatcher:
			doc := "list or watch objects of kind " + kind
			if hasSubresource {
				doc = "list or watch " + subresource + " of objects of kind " + kind
			}
			route.Doc(doc)
		case isWatcher:
			doc := "watch objects of kind " + kind
			if hasSubresource {
				doc = "watch " + subresource + "of objects of kind " + kind
			}
			route.Doc(doc)
		}
		addParams(route, action.Params)
		ws.Route(route)
	case "PUT": // Update a resource.
		doc := "replace the specified " + kind
		if hasSubresource {
			doc = "replace " + subresource + " of the specified " + kind
		}
		handler := metrics.InstrumentRouteFunc(action.Verb, resource, UpdateResource(updater, reqScope, a.group.Typer, admit))
		route := ws.PUT(action.Path).To(handler).
			Doc(doc).
			Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
			Operation("replace"+namespaced+kind+strings.Title(subresource)+operationSuffix).
			Produces(append(storageMeta.ProducesMIMETypes(action.Verb), mediaTypes...)...).
			Returns(http.StatusOK, "OK", versionedObject).
			Reads(versionedObject).
			Writes(versionedObject)
		addParams(route, action.Params)
		ws.Route(route)
	case "PATCH": // Partially update a resource
		doc := "partially update the specified " + kind
		if hasSubresource {
			doc = "partially update " + subresource + " of the specified " + kind
		}
		handler := metrics.InstrumentRouteFunc(action.Verb, resource, PatchResource(patcher, reqScope, a.group.Typer, admit, mapping.ObjectConvertor))
		route := ws.PATCH(action.Path).To(handler).
			Doc(doc).
			Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
			Consumes(string(api.JSONPatchType), string(api.MergePatchType), string(api.StrategicMergePatchType)).
			Operation("patch"+namespaced+kind+strings.Title(subresource)+operationSuffix).
			Produces(append(storageMeta.ProducesMIMETypes(action.Verb), mediaTypes...)...).
			Returns(http.StatusOK, "OK", versionedObject).
			Reads(unversioned.Patch{}).
			Writes(versionedObject)
		addParams(route, action.Params)
		ws.Route(route)
	case "POST": // Create a resource.
		var handler restful.RouteFunction
		if isNamedCreater {
			handler = CreateNamedResource(namedCreater, reqScope, a.group.Typer, admit)
		} else {
			handler = CreateResource(creater, reqScope, a.group.Typer, admit)
		}
		handler = metrics.InstrumentRouteFunc(action.Verb, resource, handler)
		article := utilstrings.GetArticleForNoun(kind, " ")
		doc := "create" + article + kind
		if hasSubresource {
			doc = "create " + subresource + " of" + article + kind
		}
		route := ws.POST(action.Path).To(handler).
			Doc(doc).
			Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
			Operation("create"+namespaced+kind+strings.Title(subresource)+operationSuffix).
			Produces(append(storageMeta.ProducesMIMETypes(action.Verb), mediaTypes...)...).
			Returns(http.StatusOK, "OK", versionedObject).
			Reads(versionedObject).
			Writes(versionedObject)
		addParams(route, action.Params)
		ws.Route(route)
	case "DELETE": // Delete a resource.
		article := utilstrings.GetArticleForNoun(kind, " ")
		doc := "delete" + article + kind
		if hasSubresource {
			doc = "delete " + subresource + " of" + article + kind
		}
		handler := metrics.InstrumentRouteFunc(action.Verb, resource, DeleteResource(gracefulDeleter, isGracefulDeleter, reqScope, admit))
		route := ws.DELETE(action.Path).To(handler).
			Doc(doc).
			Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
			Operation("delete"+namespaced+kind+strings.Title(subresource)+operationSuffix).
			Produces(append(storageMeta.ProducesMIMETypes(action.Verb), mediaTypes...)...).
			Writes(versionedStatus).
			Returns(http.StatusOK, "OK", versionedStatus)
		if isGracefulDeleter {
			route.Reads(versionedDeleterObject)
			if err := addObjectParams(ws, route, versionedDeleteOptions); err != nil {
				return nil, err
			}
		}
		addParams(route, action.Params)
		ws.Route(route)
	case "DELETECOLLECTION":
		doc := "delete collection of " + kind
		if hasSubresource {
			doc = "delete collection of " + subresource + " of a " + kind
		}
		handler := metrics.InstrumentRouteFunc(action.Verb, resource, DeleteCollection(collectionDeleter, isCollectionDeleter, reqScope, admit))
		route := ws.DELETE(action.Path).To(handler).
			Doc(doc).
			Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
			Operation("deletecollection"+namespaced+kind+strings.Title(subresource)+operationSuffix).
			Produces(append(storageMeta.ProducesMIMETypes(action.Verb), mediaTypes...)...).
			Writes(versionedStatus).
			Returns(http.StatusOK, "OK", versionedStatus)
		if err := addObjectParams(ws, route, versionedListOptions); err != nil {
			return nil, err
		}
		addParams(route, action.Params)
		ws.Route(route)
	// TODO: deprecated
	case "WATCH": // Watch a resource.
		doc := "watch changes to an object of kind " + kind
		if hasSubresource {
			doc = "watch changes to " + subresource + " of an object of kind " + kind
		}
		handler := metrics.InstrumentRouteFunc(action.Verb, resource, ListResource(lister, watcher, reqScope, true, a.minRequestTimeout))
		route := ws.GET(action.Path).To(handler).
			Doc(doc).
			Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
			Operation("watch"+namespaced+kind+strings.Title(subresource)+operationSuffix).
			Produces(allMediaTypes...).
			Returns(http.StatusOK, "OK", versionedWatchEvent).
			Writes(versionedWatchEvent)
		if err := addObjectParams(ws, route, versionedListOptions); err != nil {
			return nil, err
		}
		addParams(route, action.Params)
		ws.Route(route)
	// TODO: deprecated
	case "WATCHLIST": // Watch all resources of a kind.
		doc := "watch individual changes to a list of " + kind
		if hasSubresource {
			doc = "watch individual changes to a list of " + subresource + " of " + kind
		}
		handler := metrics.InstrumentRouteFunc(action.Verb, resource, ListResource(lister, watcher, reqScope, true, a.minRequestTimeout))
		route := ws.GET(action.Path).To(handler).
			Doc(doc).
			Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
			Operation("watch"+namespaced+kind+strings.Title(subresource)+"List"+operationSuffix).
			Produces(allMediaTypes...).
			Returns(http.StatusOK, "OK", versionedWatchEvent).
			Writes(versionedWatchEvent)
		if err := addObjectParams(ws, route, versionedListOptions); err != nil {
			return nil, err
		}
		addParams(route, action.Params)
		ws.Route(route)
	// We add "proxy" subresource to remove the need for the generic top level prefix proxy.
	// The generic top level prefix proxy is deprecated in v1.2, and will be removed in 1.3, or 1.4 at the latest.
	// TODO: DEPRECATED in v1.2.
	case "PROXY": // Proxy requests to a resource.
		// Accept all methods as per http://issue.k8s.io/3996
		addProxyRoute(ws, "GET", a.prefix, action.Path, proxyHandler, namespaced, kind, resource, subresource, hasSubresource, action.Params, operationSuffix)
		addProxyRoute(ws, "PUT", a.prefix, action.Path, proxyHandler, namespaced, kind, resource, subresource, hasSubresource, action.Params, operationSuffix)
		addProxyRoute(ws, "POST", a.prefix, action.Path, proxyHandler, namespaced, kind, resource, subresource, hasSubresource, action.Params, operationSuffix)
		addProxyRoute(ws, "DELETE", a.prefix, action.Path, proxyHandler, namespaced, kind, resource, subresource, hasSubresource, action.Params, operationSuffix)
		addProxyRoute(ws, "HEAD", a.prefix, action.Path, proxyHandler, namespaced, kind, resource, subresource, hasSubresource, action.Params, operationSuffix)
		addProxyRoute(ws, "OPTIONS", a.prefix, action.Path, proxyHandler, namespaced, kind, resource, subresource, hasSubresource, action.Params, operationSuffix)
	case "CONNECT":
		for _, method := range connecter.ConnectMethods() {
			doc := "connect " + method + " requests to " + kind
			if hasSubresource {
				doc = "connect " + method + " requests to " + subresource + " of " + kind
			}
			handler := metrics.InstrumentRouteFunc(action.Verb, resource, ConnectResource(connecter, reqScope, admit, path))
			route := ws.Method(method).Path(action.Path).
				To(handler).
				Doc(doc).
				Operation("connect" + strings.Title(strings.ToLower(method)) + namespaced + kind + strings.Title(subresource) + operationSuffix).
				Produces("*/*").
				Consumes("*/*").
				Writes("string")
			if versionedConnectOptions != nil {
				if err := addObjectParams(ws, route, versionedConnectOptions); err != nil {
					return nil, err
				}
			}
			addParams(route, action.Params)
			ws.Route(route)
		}
	default:
		return nil, fmt.Errorf("unrecognized action verb: %s", action.Verb)
	}
	// Note: update GetAttribs() when adding a custom handler.
}

以GET为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
case "GET": // Get a resource.
	var handler restful.RouteFunction
	if isGetterWithOptions {
		handler = GetResourceWithOptions(getterWithOptions, reqScope)
	} else {
		handler = GetResource(getter, exporter, reqScope)
	}
	handler = metrics.InstrumentRouteFunc(action.Verb, resource, handler)
	doc := "read the specified " + kind
	if hasSubresource {
		doc = "read " + subresource + " of the specified " + kind
	}
	route := ws.GET(action.Path).To(handler).
		Doc(doc).
		Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
		Operation("read"+namespaced+kind+strings.Title(subresource)+operationSuffix).
		Produces(append(storageMeta.ProducesMIMETypes(action.Verb), mediaTypes...)...).
		Returns(http.StatusOK, "OK", versionedObject).
		Writes(versionedObject)
	if isGetterWithOptions {
		if err := addObjectParams(ws, route, versionedGetOptions); err != nil {
			return nil, err
		}
	}
	if isExporter {
		if err := addObjectParams(ws, route, versionedExportOptions); err != nil {
			return nil, err
		}
	}
	addParams(route, action.Params)
	ws.Route(route)

可以看出，代码先定义了一个handler处理该请求。然后生成route，最后把route加入到webservice中。这完全符合emicklei/go-restful的用法。

分析结束，下一次将对路径的处理函数，即handler进行分析。