http.go

@@ -13,100 +13,103 @@ import (
 type httpServer Server
 
 // ServeHTTP implements http.Handler and has to be called on each request
-func (s httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (server httpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	defer r.Body.Close()
 
-	// 1. build API request from HTTP request
+	/* (1) create api.Request from http.Request
+	---------------------------------------------------------*/
 	request, err := api.NewRequest(r)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// 2. find a matching service for this path in the config
-	serviceDef, pathIndex := s.services.Browse(request.URI)
+	serviceConf, pathIndex := server.config.Browse(request.URI)
-	if serviceDef == nil {
+	if serviceConf == nil {
 		return
 	}
+
+	// 3. extract the service path from request URI
 	servicePath := strings.Join(request.URI[:pathIndex], "/")
 	if !strings.HasPrefix(servicePath, "/") {
 		servicePath = "/" + servicePath
 	}
 
-	// 3. check if matching methodDef exists in config */
+	// 4. find method configuration from http method */
-	var methodDef = serviceDef.Method(r.Method)
+	var methodConf = serviceConf.Method(r.Method)
-	if methodDef == nil {
+	if methodConf == nil {
-		response := api.NewResponse(api.ErrorUnknownMethod())
+		res := api.NewResponse(api.ErrorUnknownMethod())
-		response.ServeHTTP(w, r)
+		res.ServeHTTP(w, r)
-		logError(response)
+		logError(res)
 		return
 	}
 
-	// 4. parse every input data from the request
+	// 5. parse data from the request (uri, query, form, json)
-	store := reqdata.New(request.URI[pathIndex:], r)
+	data := reqdata.New(request.URI[pathIndex:], r)
 
-	/* (4) Check parameters
+	/* (2) check parameters
 	---------------------------------------------------------*/
-	parameters, paramError := s.extractParameters(store, methodDef.Parameters)
+	parameters, paramError := server.extractParameters(data, methodConf.Parameters)
 
 	// Fail if argument check failed
 	if paramError.Code != api.ErrorSuccess().Code {
-		response := api.NewResponse(paramError)
+		res := api.NewResponse(paramError)
-		response.ServeHTTP(w, r)
+		res.ServeHTTP(w, r)
-		logError(response)
+		logError(res)
 		return
 	}
 
 	request.Param = parameters
 
-	/* (5) Search a matching handler
+	/* (3) search for the handler
 	---------------------------------------------------------*/
-	var serviceHandler *api.Handler
+	var foundHandler *api.Handler
-	var serviceFound bool
+	var found bool
 
-	for _, handler := range s.handlers {
+	for _, handler := range server.handlers {
 		if handler.GetPath() == servicePath {
-			serviceFound = true
+			found = true
 			if handler.GetMethod() == r.Method {
-				serviceHandler = handler
+				foundHandler = handler
 			}
 		}
 	}
 
 	// fail if found no handler
-	if serviceHandler == nil {
+	if foundHandler == nil {
-		if serviceFound {
+		if found {
-			response := api.NewResponse()
+			res := api.NewResponse()
-			response.SetError(api.ErrorUncallableMethod(), servicePath, r.Method)
+			res.SetError(api.ErrorUncallableMethod(), servicePath, r.Method)
-			response.ServeHTTP(w, r)
+			res.ServeHTTP(w, r)
-			logError(response)
+			logError(res)
 			return
 		}
 
-		response := api.NewResponse()
+		res := api.NewResponse()
-		response.SetError(api.ErrorUncallableService(), servicePath)
+		res.SetError(api.ErrorUncallableService(), servicePath)
-		response.ServeHTTP(w, r)
+		res.ServeHTTP(w, r)
-		logError(response)
+		logError(res)
 		return
 	}
 
-	/* (6) Execute handler and return response
+	/* (4) execute handler and return response
 	---------------------------------------------------------*/
 	// 1. feed request with configuration scope
-	request.Scope = methodDef.Scope
+	request.Scope = methodConf.Scope
 
-	// 1. execute
+	// 2. execute
-	response := api.NewResponse()
+	res := api.NewResponse()
-	serviceHandler.Handle(*request, response)
+	foundHandler.Handle(*request, res)
 
-	// 2. apply headers
+	// 3. apply headers
-	for key, values := range response.Headers {
+	for key, values := range res.Headers {
 		for _, value := range values {
 			w.Header().Add(key, value)
 		}
 	}
 
-	// 3. write to response
+	// 4. write to response
-	response.ServeHTTP(w, r)
+	res.ServeHTTP(w, r)
 	return
 
 }

server.go

@@ -13,7 +13,7 @@ import (
 
 // Server represents an AICRA instance featuring: type checkers, services
 type Server struct {
-	services *config.Service
+	config   *config.Service
 	Checkers *checker.Set
 	handlers []*api.Handler
 }
@@ -27,7 +27,7 @@ func New(configPath string) (*Server, error) {
 
 	// 1. init instance
 	var i = &Server{
-		services: nil,
+		config:   nil,
 		Checkers: checker.New(),
 		handlers: make([]*api.Handler, 0),
 	}
@@ -40,14 +40,14 @@ func New(configPath string) (*Server, error) {
 	defer configFile.Close()
 
 	// 3. load configuration
-	i.services, err = config.Parse(configFile)
+	i.config, err = config.Parse(configFile)
 	if err != nil {
 		return nil, err
 	}
 
 	// 4. log configuration services
 	log.Printf("🔧   Reading configuration '%s'\n", configPath)
-	logService(*i.services, "")
+	logService(*i.config, "")
 
 	return i, nil
 

util.go

@@ -58,7 +58,7 @@ func (s *httpServer) extractParameters(store *reqdata.Store, methodParam map[str
 			return nil, apiErr
 		}
 
-		// 6. do not check if file
+		// 6. ignore type check if file
 		if gotFile {
 			parameters[param.Rename] = p.Value
 			continue