diff --git a/config/reference_config.go b/config/reference_config.go
index b9f3da13527c4c7de851dac9e5cd8ecf4638758b..dcdba958058edb7c1f59f49f20a4cb738ea102f8 100644
--- a/config/reference_config.go
+++ b/config/reference_config.go
@@ -188,7 +188,6 @@ func (c *ReferenceConfig) getUrlMap() url.Values {
urlMap.Set(constant.VERSION_KEY, c.Version)
urlMap.Set(constant.GENERIC_KEY, strconv.FormatBool(c.Generic))
urlMap.Set(constant.ROLE_KEY, strconv.Itoa(common.CONSUMER))
- urlMap.Set(constant.CATEGORY_KEY, (common.RoleType(common.CONSUMER)).String())
urlMap.Set(constant.RELEASE_KEY, "dubbo-golang-"+constant.Version)
urlMap.Set(constant.SIDE_KEY, (common.RoleType(common.CONSUMER)).Role())
diff --git a/protocol/rest/client/client_impl/resty_client.go b/protocol/rest/client/client_impl/resty_client.go
index aa6c23137dc68492948b85a85555a5340572ac49..b60f50a5a70cde01a051dbb2a4490cbb792e0116 100644
--- a/protocol/rest/client/client_impl/resty_client.go
+++ b/protocol/rest/client/client_impl/resty_client.go
@@ -40,10 +40,12 @@ func init() {
extension.SetRestClient(constant.DEFAULT_REST_CLIENT, NewRestyClient)
}
+// RestyClient a rest client implement by Resty
type RestyClient struct {
client *resty.Client
}
+// NewRestyClient a constructor of RestyClient
func NewRestyClient(restOption *client.RestOptions) client.RestClient {
client := resty.New()
client.SetTransport(
@@ -65,21 +67,21 @@ func NewRestyClient(restOption *client.RestOptions) client.RestClient {
}
}
-func (rc *RestyClient) Do(restRequest *client.RestRequest, res interface{}) error {
- r, err := rc.client.R().
- SetHeader("Content-Type", restRequest.Consumes).
- SetHeader("Accept", restRequest.Produces).
+// Do send request by RestyClient
+func (rc *RestyClient) Do(restRequest *client.RestClientRequest, res interface{}) error {
+ req := rc.client.R()
+ req.Header = restRequest.Header
+ resp, err := req.
SetPathParams(restRequest.PathParams).
SetQueryParams(restRequest.QueryParams).
- SetHeaders(restRequest.Headers).
SetBody(restRequest.Body).
SetResult(res).
Execute(restRequest.Method, "http://"+path.Join(restRequest.Location, restRequest.Path))
if err != nil {
return perrors.WithStack(err)
}
- if r.IsError() {
- return perrors.New(r.String())
+ if resp.IsError() {
+ return perrors.New(resp.String())
}
return nil
}
diff --git a/protocol/rest/client/rest_client.go b/protocol/rest/client/rest_client.go
index 7d020abc81c2bd44473ed25ffec4b2b657e7bcc0..d63c5e0bd0c7e6392eb5b0efc50bb0a585f4192d 100644
--- a/protocol/rest/client/rest_client.go
+++ b/protocol/rest/client/rest_client.go
@@ -18,26 +18,28 @@
package client
import (
+ "net/http"
"time"
)
+// RestOptions
type RestOptions struct {
RequestTimeout time.Duration
ConnectTimeout time.Duration
}
-type RestRequest struct {
+// RestClientRequest
+type RestClientRequest struct {
+ Header http.Header
Location string
Path string
- Produces string
- Consumes string
Method string
PathParams map[string]string
QueryParams map[string]string
Body interface{}
- Headers map[string]string
}
+// RestClient user can implement this client interface to send request
type RestClient interface {
- Do(request *RestRequest, res interface{}) error
+ Do(request *RestClientRequest, res interface{}) error
}
diff --git a/protocol/rest/rest_invoker.go b/protocol/rest/rest_invoker.go
index 0c82035ac5eb9a52ab188baa971dbdf1b864e970..121d1217efd3baea0f961b67e243e9a0450aefc2 100644
--- a/protocol/rest/rest_invoker.go
+++ b/protocol/rest/rest_invoker.go
@@ -20,6 +20,7 @@ package rest
import (
"context"
"fmt"
+ "net/http"
)
import (
@@ -56,7 +57,7 @@ func (ri *RestInvoker) Invoke(ctx context.Context, invocation protocol.Invocatio
body interface{}
pathParams map[string]string
queryParams map[string]string
- headers map[string]string
+ header http.Header
err error
)
if methodConfig == nil {
@@ -71,24 +72,21 @@ func (ri *RestInvoker) Invoke(ctx context.Context, invocation protocol.Invocatio
result.Err = err
return &result
}
- if headers, err = restStringMapTransform(methodConfig.HeadersMap, inv.Arguments()); err != nil {
+ if header, err = getRestHttpHeader(methodConfig, inv.Arguments()); err != nil {
result.Err = err
return &result
}
if len(inv.Arguments()) > methodConfig.Body && methodConfig.Body >= 0 {
body = inv.Arguments()[methodConfig.Body]
}
-
- req := &client.RestRequest{
+ req := &client.RestClientRequest{
Location: ri.GetUrl().Location,
- Produces: methodConfig.Produces,
- Consumes: methodConfig.Consumes,
Method: methodConfig.MethodType,
Path: methodConfig.Path,
PathParams: pathParams,
QueryParams: queryParams,
Body: body,
- Headers: headers,
+ Header: header,
}
result.Err = ri.client.Do(req, inv.Reply())
if result.Err == nil {
@@ -107,3 +105,17 @@ func restStringMapTransform(paramsMap map[int]string, args []interface{}) (map[s
}
return resMap, nil
}
+
+func getRestHttpHeader(methodConfig *config.RestMethodConfig, args []interface{}) (http.Header, error) {
+ header := http.Header{}
+ headersMap := methodConfig.HeadersMap
+ header.Set("Content-Type", methodConfig.Consumes)
+ header.Set("Accept", methodConfig.Produces)
+ for k, v := range headersMap {
+ if k >= len(args) || k < 0 {
+ return nil, perrors.Errorf("[Rest Invoke] Index %v is out of bundle", k)
+ }
+ header.Set(v, fmt.Sprint(args[k]))
+ }
+ return header, nil
+}
diff --git a/protocol/rest/rest_protocol.go b/protocol/rest/rest_protocol.go
index 47ecb6093b4cfa12a1d3397fa45d59b1e173a93a..e15eeb39d72212eb9f1d0235313eba231d3b0a36 100644
--- a/protocol/rest/rest_protocol.go
+++ b/protocol/rest/rest_protocol.go
@@ -75,7 +75,9 @@ func (rp *RestProtocol) Export(invoker protocol.Invoker) protocol.Exporter {
}
rp.SetExporterMap(serviceKey, exporter)
restServer := rp.getServer(url, restServiceConfig.Server)
- restServer.Deploy(invoker, restServiceConfig.RestMethodConfigsMap)
+ for _, methodConfig := range restServiceConfig.RestMethodConfigsMap {
+ restServer.Deploy(methodConfig, server.GetRouteFunc(invoker, methodConfig))
+ }
return exporter
}
diff --git a/protocol/rest/server/rest_server.go b/protocol/rest/server/rest_server.go
index c10c98a7b677d47c43b64643a69d5b3768a6c663..fbd6fb7ad9dd81f043e4d45ee94a54e12ef89cdd 100644
--- a/protocol/rest/server/rest_server.go
+++ b/protocol/rest/server/rest_server.go
@@ -17,15 +17,306 @@
package server
+import (
+ "context"
+ "errors"
+ "net/http"
+ "reflect"
+ "strconv"
+ "strings"
+)
+
+import (
+ perrors "github.com/pkg/errors"
+)
+
import (
"github.com/apache/dubbo-go/common"
+ "github.com/apache/dubbo-go/common/logger"
"github.com/apache/dubbo-go/protocol"
- "github.com/apache/dubbo-go/protocol/rest/config"
+ "github.com/apache/dubbo-go/protocol/invocation"
+ rest_config "github.com/apache/dubbo-go/protocol/rest/config"
)
+const parseParameterErrorStr = "An error occurred while parsing parameters on the server"
+
+// RestServer user can implement this server interface
type RestServer interface {
+ // Start rest server
Start(url common.URL)
- Deploy(invoker protocol.Invoker, restMethodConfig map[string]*config.RestMethodConfig)
- UnDeploy(restMethodConfig map[string]*config.RestMethodConfig)
+ // Deploy a http api
+ Deploy(restMethodConfig *rest_config.RestMethodConfig, routeFunc func(request RestServerRequest, response RestServerResponse))
+ // UnDeploy a http api
+ UnDeploy(restMethodConfig *rest_config.RestMethodConfig)
+ // Destroy rest server
Destroy()
}
+
+// RestServerRequest interface
+type RestServerRequest interface {
+ // RawRequest get the Ptr of http.Request
+ RawRequest() *http.Request
+ // PathParameter get the path parameter by name
+ PathParameter(name string) string
+ // PathParameters get the map of the path parameters
+ PathParameters() map[string]string
+ // QueryParameter get the query parameter by name
+ QueryParameter(name string) string
+ // QueryParameters get the map of query parameters
+ QueryParameters(name string) []string
+ // BodyParameter get the body parameter of name
+ BodyParameter(name string) (string, error)
+ // HeaderParameter get the header parameter of name
+ HeaderParameter(name string) string
+ // ReadEntity checks the Accept header and reads the content into the entityPointer.
+ ReadEntity(entityPointer interface{}) error
+}
+
+// RestServerResponse interface
+type RestServerResponse interface {
+ http.ResponseWriter
+ // WriteError writes the http status and the error string on the response. err can be nil.
+ // Return an error if writing was not successful.
+ WriteError(httpStatus int, err error) (writeErr error)
+ // WriteEntity marshals the value using the representation denoted by the Accept Header.
+ WriteEntity(value interface{}) error
+}
+
+// GetRouteFunc
+// A route function will be invoked by http server
+func GetRouteFunc(invoker protocol.Invoker, methodConfig *rest_config.RestMethodConfig) func(req RestServerRequest, resp RestServerResponse) {
+ return func(req RestServerRequest, resp RestServerResponse) {
+ var (
+ err error
+ args []interface{}
+ )
+ svc := common.ServiceMap.GetService(invoker.GetUrl().Protocol, strings.TrimPrefix(invoker.GetUrl().Path, "/"))
+ // get method
+ method := svc.Method()[methodConfig.MethodName]
+ argsTypes := method.ArgsType()
+ replyType := method.ReplyType()
+ // two ways to prepare arguments
+ // if method like this 'func1(req []interface{}, rsp *User) error'
+ // we don't have arguments type
+ if (len(argsTypes) == 1 || len(argsTypes) == 2 && replyType == nil) &&
+ argsTypes[0].String() == "[]interface {}" {
+ args, err = getArgsInterfaceFromRequest(req, methodConfig)
+ } else {
+ args, err = getArgsFromRequest(req, argsTypes, methodConfig)
+ }
+ if err != nil {
+ logger.Errorf("[Go Restful] parsing http parameters error:%v", err)
+ err = resp.WriteError(http.StatusInternalServerError, errors.New(parseParameterErrorStr))
+ if err != nil {
+ logger.Errorf("[Go Restful] WriteErrorString error:%v", err)
+ }
+ }
+ result := invoker.Invoke(context.Background(), invocation.NewRPCInvocation(methodConfig.MethodName, args, make(map[string]string)))
+ if result.Error() != nil {
+ err = resp.WriteError(http.StatusInternalServerError, result.Error())
+ if err != nil {
+ logger.Errorf("[Go Restful] WriteError error:%v", err)
+ }
+ return
+ }
+ err = resp.WriteEntity(result.Result())
+ if err != nil {
+ logger.Errorf("[Go Restful] WriteEntity error:%v", err)
+ }
+ }
+}
+
+// getArgsInterfaceFromRequest when service function like GetUser(req []interface{}, rsp *User) error
+// use this method to get arguments
+func getArgsInterfaceFromRequest(req RestServerRequest, methodConfig *rest_config.RestMethodConfig) ([]interface{}, error) {
+ argsMap := make(map[int]interface{}, 8)
+ maxKey := 0
+ for k, v := range methodConfig.PathParamsMap {
+ if maxKey < k {
+ maxKey = k
+ }
+ argsMap[k] = req.PathParameter(v)
+ }
+ for k, v := range methodConfig.QueryParamsMap {
+ if maxKey < k {
+ maxKey = k
+ }
+ params := req.QueryParameters(v)
+ if len(params) == 1 {
+ argsMap[k] = params[0]
+ } else {
+ argsMap[k] = params
+ }
+ }
+ for k, v := range methodConfig.HeadersMap {
+ if maxKey < k {
+ maxKey = k
+ }
+ argsMap[k] = req.HeaderParameter(v)
+ }
+ if methodConfig.Body >= 0 {
+ if maxKey < methodConfig.Body {
+ maxKey = methodConfig.Body
+ }
+ m := make(map[string]interface{})
+ // TODO read as a slice
+ if err := req.ReadEntity(&m); err != nil {
+ return nil, perrors.Errorf("[Go restful] Read body entity as map[string]interface{} error:%v", err)
+ }
+ argsMap[methodConfig.Body] = m
+ }
+ args := make([]interface{}, maxKey+1)
+ for k, v := range argsMap {
+ if k >= 0 {
+ args[k] = v
+ }
+ }
+ return args, nil
+}
+
+// getArgsFromRequest get arguments from server.RestServerRequest
+func getArgsFromRequest(req RestServerRequest, argsTypes []reflect.Type, methodConfig *rest_config.RestMethodConfig) ([]interface{}, error) {
+ argsLength := len(argsTypes)
+ args := make([]interface{}, argsLength)
+ for i, t := range argsTypes {
+ args[i] = reflect.Zero(t).Interface()
+ }
+ if err := assembleArgsFromPathParams(methodConfig, argsLength, argsTypes, req, args); err != nil {
+ return nil, err
+ }
+ if err := assembleArgsFromQueryParams(methodConfig, argsLength, argsTypes, req, args); err != nil {
+ return nil, err
+ }
+ if err := assembleArgsFromBody(methodConfig, argsTypes, req, args); err != nil {
+ return nil, err
+ }
+ if err := assembleArgsFromHeaders(methodConfig, req, argsLength, argsTypes, args); err != nil {
+ return nil, err
+ }
+ return args, nil
+}
+
+// assembleArgsFromHeaders assemble arguments from headers
+func assembleArgsFromHeaders(methodConfig *rest_config.RestMethodConfig, req RestServerRequest, argsLength int, argsTypes []reflect.Type, args []interface{}) error {
+ for k, v := range methodConfig.HeadersMap {
+ param := req.HeaderParameter(v)
+ if k < 0 || k >= argsLength {
+ return perrors.Errorf("[Go restful] Header param parse error, the index %v args of method:%v doesn't exist", k, methodConfig.MethodName)
+ }
+ t := argsTypes[k]
+ if t.Kind() == reflect.Ptr {
+ t = t.Elem()
+ }
+ if t.Kind() == reflect.String {
+ args[k] = param
+ } else {
+ return perrors.Errorf("[Go restful] Header param parse error, the index %v args's type isn't string", k)
+ }
+ }
+ return nil
+}
+
+// assembleArgsFromBody assemble arguments from body
+func assembleArgsFromBody(methodConfig *rest_config.RestMethodConfig, argsTypes []reflect.Type, req RestServerRequest, args []interface{}) error {
+ if methodConfig.Body >= 0 && methodConfig.Body < len(argsTypes) {
+ t := argsTypes[methodConfig.Body]
+ kind := t.Kind()
+ if kind == reflect.Ptr {
+ t = t.Elem()
+ }
+ var ni interface{}
+ if t.String() == "[]interface {}" {
+ ni = make([]map[string]interface{}, 0)
+ } else if t.String() == "interface {}" {
+ ni = make(map[string]interface{})
+ } else {
+ n := reflect.New(t)
+ if n.CanInterface() {
+ ni = n.Interface()
+ }
+ }
+ if err := req.ReadEntity(&ni); err != nil {
+ return perrors.Errorf("[Go restful] Read body entity error, error is %v", perrors.WithStack(err))
+ }
+ args[methodConfig.Body] = ni
+ }
+ return nil
+}
+
+// assembleArgsFromQueryParams assemble arguments from query params
+func assembleArgsFromQueryParams(methodConfig *rest_config.RestMethodConfig, argsLength int, argsTypes []reflect.Type, req RestServerRequest, args []interface{}) error {
+ var (
+ err error
+ param interface{}
+ i64 int64
+ )
+ for k, v := range methodConfig.QueryParamsMap {
+ if k < 0 || k >= argsLength {
+ return perrors.Errorf("[Go restful] Query param parse error, the index %v args of method:%v doesn't exist", k, methodConfig.MethodName)
+ }
+ t := argsTypes[k]
+ kind := t.Kind()
+ if kind == reflect.Ptr {
+ t = t.Elem()
+ }
+ if kind == reflect.Slice {
+ param = req.QueryParameters(v)
+ } else if kind == reflect.String {
+ param = req.QueryParameter(v)
+ } else if kind == reflect.Int {
+ param, err = strconv.Atoi(req.QueryParameter(v))
+ } else if kind == reflect.Int32 {
+ i64, err = strconv.ParseInt(req.QueryParameter(v), 10, 32)
+ if err == nil {
+ param = int32(i64)
+ }
+ } else if kind == reflect.Int64 {
+ param, err = strconv.ParseInt(req.QueryParameter(v), 10, 64)
+ } else {
+ return perrors.Errorf("[Go restful] Query param parse error, the index %v args's type isn't int or string or slice", k)
+ }
+ if err != nil {
+ return perrors.Errorf("[Go restful] Query param parse error, error:%v", perrors.WithStack(err))
+ }
+ args[k] = param
+ }
+ return nil
+}
+
+// assembleArgsFromPathParams assemble arguments from path params
+func assembleArgsFromPathParams(methodConfig *rest_config.RestMethodConfig, argsLength int, argsTypes []reflect.Type, req RestServerRequest, args []interface{}) error {
+ var (
+ err error
+ param interface{}
+ i64 int64
+ )
+ for k, v := range methodConfig.PathParamsMap {
+ if k < 0 || k >= argsLength {
+ return perrors.Errorf("[Go restful] Path param parse error, the index %v args of method:%v doesn't exist", k, methodConfig.MethodName)
+ }
+ t := argsTypes[k]
+ kind := t.Kind()
+ if kind == reflect.Ptr {
+ t = t.Elem()
+ }
+ if kind == reflect.Int {
+ param, err = strconv.Atoi(req.PathParameter(v))
+ } else if kind == reflect.Int32 {
+ i64, err = strconv.ParseInt(req.PathParameter(v), 10, 32)
+ if err == nil {
+ param = int32(i64)
+ }
+ } else if kind == reflect.Int64 {
+ param, err = strconv.ParseInt(req.PathParameter(v), 10, 64)
+ } else if kind == reflect.String {
+ param = req.PathParameter(v)
+ } else {
+ return perrors.Errorf("[Go restful] Path param parse error, the index %v args's type isn't int or string", k)
+ }
+ if err != nil {
+ return perrors.Errorf("[Go restful] Path param parse error, error is %v", perrors.WithStack(err))
+ }
+ args[k] = param
+ }
+ return nil
+}
diff --git a/protocol/rest/server/server_impl/go_restful_server.go b/protocol/rest/server/server_impl/go_restful_server.go
index 69f36a5c80aa51f52dfcfabc5a1bd4003f4cd727..c7d971fcaa5ada0ba02cc436b5ae6705793887ef 100644
--- a/protocol/rest/server/server_impl/go_restful_server.go
+++ b/protocol/rest/server/server_impl/go_restful_server.go
@@ -22,8 +22,6 @@ import (
"fmt"
"net"
"net/http"
- "reflect"
- "strconv"
"strings"
"time"
)
@@ -38,27 +36,29 @@ import (
"github.com/apache/dubbo-go/common/constant"
"github.com/apache/dubbo-go/common/extension"
"github.com/apache/dubbo-go/common/logger"
- "github.com/apache/dubbo-go/protocol"
- "github.com/apache/dubbo-go/protocol/invocation"
"github.com/apache/dubbo-go/protocol/rest/config"
"github.com/apache/dubbo-go/protocol/rest/server"
)
func init() {
- extension.SetRestServer(constant.DEFAULT_REST_SERVER, GetNewGoRestfulServer)
+ extension.SetRestServer(constant.DEFAULT_REST_SERVER, NewGoRestfulServer)
}
var filterSlice []restful.FilterFunction
+// GoRestfulServer a rest server implement by go-restful
type GoRestfulServer struct {
srv *http.Server
container *restful.Container
}
-func NewGoRestfulServer() *GoRestfulServer {
+// NewGoRestfulServer a constructor of GoRestfulServer
+func NewGoRestfulServer() server.RestServer {
return &GoRestfulServer{}
}
+// Start go-restful server
+// It will add all go-restful filters
func (grs *GoRestfulServer) Start(url common.URL) {
grs.container = restful.NewContainer()
for _, filter := range filterSlice {
@@ -80,61 +80,32 @@ func (grs *GoRestfulServer) Start(url common.URL) {
}()
}
-func (grs *GoRestfulServer) Deploy(invoker protocol.Invoker, restMethodConfig map[string]*config.RestMethodConfig) {
- svc := common.ServiceMap.GetService(invoker.GetUrl().Protocol, strings.TrimPrefix(invoker.GetUrl().Path, "/"))
- for methodName, config := range restMethodConfig {
- // get method
- method := svc.Method()[methodName]
- argsTypes := method.ArgsType()
- replyType := method.ReplyType()
- ws := new(restful.WebService)
- ws.Path(config.Path).
- Produces(strings.Split(config.Produces, ",")...).
- Consumes(strings.Split(config.Consumes, ",")...).
- Route(ws.Method(config.MethodType).To(getFunc(methodName, invoker, argsTypes, replyType, config)))
- grs.container.Add(ws)
+// Publish a http api in go-restful server
+// The routeFunc should be invoked when the server receive a request
+func (grs *GoRestfulServer) Deploy(restMethodConfig *config.RestMethodConfig, routeFunc func(request server.RestServerRequest, response server.RestServerResponse)) {
+ ws := &restful.WebService{}
+ rf := func(req *restful.Request, resp *restful.Response) {
+ routeFunc(NewGoRestfulRequestAdapter(req), resp)
}
+ ws.Path(restMethodConfig.Path).
+ Produces(strings.Split(restMethodConfig.Produces, ",")...).
+ Consumes(strings.Split(restMethodConfig.Consumes, ",")...).
+ Route(ws.Method(restMethodConfig.MethodType).To(rf))
+ grs.container.Add(ws)
}
-func getFunc(methodName string, invoker protocol.Invoker, argsTypes []reflect.Type,
- replyType reflect.Type, config *config.RestMethodConfig) func(req *restful.Request, resp *restful.Response) {
- return func(req *restful.Request, resp *restful.Response) {
- var (
- err error
- args []interface{}
- )
- if (len(argsTypes) == 1 || len(argsTypes) == 2 && replyType == nil) &&
- argsTypes[0].String() == "[]interface {}" {
- args = getArgsInterfaceFromRequest(req, config)
- } else {
- args = getArgsFromRequest(req, argsTypes, config)
- }
- result := invoker.Invoke(context.Background(), invocation.NewRPCInvocation(methodName, args, make(map[string]string)))
- if result.Error() != nil {
- err = resp.WriteError(http.StatusInternalServerError, result.Error())
- if err != nil {
- logger.Errorf("[Go Restful] WriteError error:%v", err)
- }
- return
- }
- err = resp.WriteEntity(result.Result())
- if err != nil {
- logger.Error("[Go Restful] WriteEntity error:%v", err)
- }
- }
-}
-func (grs *GoRestfulServer) UnDeploy(restMethodConfig map[string]*config.RestMethodConfig) {
- for _, config := range restMethodConfig {
- ws := new(restful.WebService)
- ws.Path(config.Path)
- err := grs.container.Remove(ws)
- if err != nil {
- logger.Warnf("[Go restful] Remove web service error:%v", err)
- }
+// Delete a http api in go-restful server
+func (grs *GoRestfulServer) UnDeploy(restMethodConfig *config.RestMethodConfig) {
+ ws := new(restful.WebService)
+ ws.Path(restMethodConfig.Path)
+ err := grs.container.Remove(ws)
+ if err != nil {
+ logger.Warnf("[Go restful] Remove web service error:%v", err)
}
}
+// Destroy the go-restful server
func (grs *GoRestfulServer) Destroy() {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
@@ -144,179 +115,59 @@ func (grs *GoRestfulServer) Destroy() {
logger.Infof("[Go Restful] Server exiting")
}
-func getArgsInterfaceFromRequest(req *restful.Request, config *config.RestMethodConfig) []interface{} {
- argsMap := make(map[int]interface{}, 8)
- maxKey := 0
- for k, v := range config.PathParamsMap {
- if maxKey < k {
- maxKey = k
- }
- argsMap[k] = req.PathParameter(v)
- }
- for k, v := range config.QueryParamsMap {
- if maxKey < k {
- maxKey = k
- }
- params := req.QueryParameters(v)
- if len(params) == 1 {
- argsMap[k] = params[0]
- } else {
- argsMap[k] = params
- }
- }
- for k, v := range config.HeadersMap {
- if maxKey < k {
- maxKey = k
- }
- argsMap[k] = req.HeaderParameter(v)
- }
- if config.Body >= 0 {
- if maxKey < config.Body {
- maxKey = config.Body
- }
- m := make(map[string]interface{})
- // TODO read as a slice
- if err := req.ReadEntity(&m); err != nil {
- logger.Warnf("[Go restful] Read body entity as map[string]interface{} error:%v", perrors.WithStack(err))
- } else {
- argsMap[config.Body] = m
- }
- }
- args := make([]interface{}, maxKey+1)
- for k, v := range argsMap {
- if k >= 0 {
- args[k] = v
- }
- }
- return args
+// AddGoRestfulServerFilter let user add the http server of go-restful
+// addFilter should before config.Load()
+func AddGoRestfulServerFilter(filterFuc restful.FilterFunction) {
+ filterSlice = append(filterSlice, filterFuc)
}
-func getArgsFromRequest(req *restful.Request, argsTypes []reflect.Type, config *config.RestMethodConfig) []interface{} {
- argsLength := len(argsTypes)
- args := make([]interface{}, argsLength)
- for i, t := range argsTypes {
- args[i] = reflect.Zero(t).Interface()
- }
- var (
- err error
- param interface{}
- i64 int64
- )
- for k, v := range config.PathParamsMap {
- if k < 0 || k >= argsLength {
- logger.Errorf("[Go restful] Path param parse error, the args:%v doesn't exist", k)
- continue
- }
- t := argsTypes[k]
- kind := t.Kind()
- if kind == reflect.Ptr {
- t = t.Elem()
- }
- if kind == reflect.Int {
- param, err = strconv.Atoi(req.PathParameter(v))
- } else if kind == reflect.Int32 {
- i64, err = strconv.ParseInt(req.PathParameter(v), 10, 32)
- if err == nil {
- param = int32(i64)
- }
- } else if kind == reflect.Int64 {
- param, err = strconv.ParseInt(req.PathParameter(v), 10, 64)
- } else if kind == reflect.String {
- param = req.PathParameter(v)
- } else {
- logger.Warnf("[Go restful] Path param parse error, the args:%v of type isn't int or string", k)
- continue
- }
- if err != nil {
- logger.Errorf("[Go restful] Path param parse error, error is %v", err)
- continue
- }
- args[k] = param
- }
- for k, v := range config.QueryParamsMap {
- if k < 0 || k >= argsLength {
- logger.Errorf("[Go restful] Query param parse error, the args:%v doesn't exist", k)
- continue
- }
- t := argsTypes[k]
- kind := t.Kind()
- if kind == reflect.Ptr {
- t = t.Elem()
- }
- if kind == reflect.Slice {
- param = req.QueryParameters(v)
- } else if kind == reflect.String {
- param = req.QueryParameter(v)
- } else if kind == reflect.Int {
- param, err = strconv.Atoi(req.QueryParameter(v))
- } else if kind == reflect.Int32 {
- i64, err = strconv.ParseInt(req.QueryParameter(v), 10, 32)
- if err == nil {
- param = int32(i64)
- }
- } else if kind == reflect.Int64 {
- param, err = strconv.ParseInt(req.QueryParameter(v), 10, 64)
- } else {
- logger.Errorf("[Go restful] Query param parse error, the args:%v of type isn't int or string or slice", k)
- continue
- }
- if err != nil {
- logger.Errorf("[Go restful] Query param parse error, error is %v", err)
- continue
- }
- args[k] = param
- }
+// GoRestfulRequestAdapter a adapter struct about RestServerRequest
+type GoRestfulRequestAdapter struct {
+ server.RestServerRequest
+ request *restful.Request
+}
- if config.Body >= 0 && config.Body < len(argsTypes) {
- t := argsTypes[config.Body]
- kind := t.Kind()
- if kind == reflect.Ptr {
- t = t.Elem()
- }
- var ni interface{}
- if t.String() == "[]interface {}" {
- ni = make([]map[string]interface{}, 0)
- } else if t.String() == "interface {}" {
- ni = make(map[string]interface{})
- } else {
- n := reflect.New(t)
- if n.CanInterface() {
- ni = n.Interface()
- }
- }
- if err := req.ReadEntity(&ni); err != nil {
- logger.Errorf("[Go restful] Read body entity error:%v", err)
- } else {
- args[config.Body] = ni
- }
- }
+// NewGoRestfulRequestAdapter a constructor of GoRestfulRequestAdapter
+func NewGoRestfulRequestAdapter(request *restful.Request) *GoRestfulRequestAdapter {
+ return &GoRestfulRequestAdapter{request: request}
+}
- for k, v := range config.HeadersMap {
- param := req.HeaderParameter(v)
- if k < 0 || k >= argsLength {
- logger.Errorf("[Go restful] Header param parse error, the args:%v doesn't exist", k)
- continue
- }
- t := argsTypes[k]
- if t.Kind() == reflect.Ptr {
- t = t.Elem()
- }
- if t.Kind() == reflect.String {
- args[k] = param
- } else {
- logger.Errorf("[Go restful] Header param parse error, the args:%v of type isn't string", k)
- }
- }
+// RawRequest a adapter function of server.RestServerRequest's RawRequest
+func (grra *GoRestfulRequestAdapter) RawRequest() *http.Request {
+ return grra.request.Request
+}
- return args
+// PathParameter a adapter function of server.RestServerRequest's PathParameter
+func (grra *GoRestfulRequestAdapter) PathParameter(name string) string {
+ return grra.request.PathParameter(name)
}
-func GetNewGoRestfulServer() server.RestServer {
- return NewGoRestfulServer()
+// PathParameters a adapter function of server.RestServerRequest's QueryParameter
+func (grra *GoRestfulRequestAdapter) PathParameters() map[string]string {
+ return grra.request.PathParameters()
}
-// Let user addFilter
-// addFilter should before config.Load()
-func AddGoRestfulServerFilter(filterFuc restful.FilterFunction) {
- filterSlice = append(filterSlice, filterFuc)
+// QueryParameter a adapter function of server.RestServerRequest's QueryParameters
+func (grra *GoRestfulRequestAdapter) QueryParameter(name string) string {
+ return grra.request.QueryParameter(name)
+}
+
+// QueryParameters a adapter function of server.RestServerRequest's QueryParameters
+func (grra *GoRestfulRequestAdapter) QueryParameters(name string) []string {
+ return grra.request.QueryParameters(name)
+}
+
+// BodyParameter a adapter function of server.RestServerRequest's BodyParameter
+func (grra *GoRestfulRequestAdapter) BodyParameter(name string) (string, error) {
+ return grra.request.BodyParameter(name)
+}
+
+// HeaderParameter a adapter function of server.RestServerRequest's HeaderParameter
+func (grra *GoRestfulRequestAdapter) HeaderParameter(name string) string {
+ return grra.request.HeaderParameter(name)
+}
+
+// ReadEntity a adapter func of server.RestServerRequest's ReadEntity
+func (grra *GoRestfulRequestAdapter) ReadEntity(entityPointer interface{}) error {
+ return grra.request.ReadEntity(entityPointer)
}