func (p *Resource) HostsAddHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("HostsAddHandler is called!")
number := req.QueryParameter("number")
logrus.Infof("Number is %s \n", number)
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
objectId := req.PathParameter(ParamID)
logrus.Debugf("cluster id is %d \n", objectId)
cluster, errorCode, err := services.GetClusterService().AddHosts(objectId, number, x_auth_token)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
res := response.QueryStruct{Success: true, Data: cluster}
resp.WriteEntity(res)
return
}
// UserLoginHandler parses the http request and login with an exist user.
// Usage :
// POST v1/user/login
// If successful,response code will be set to 201.
func (p *Resource) UserLoginHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("UserLoginHandler is called!")
doc := bson.M{}
decoder := json.NewDecoder(req.Request.Body)
err := decoder.Decode(&doc)
if err != nil {
logrus.Errorf("decode user err is %v", err)
response.WriteStatusError(services.USER_ERROR_LOGIN, err, resp)
return
}
username, password, paraErr := userLoginParamCheck(doc)
if paraErr != nil {
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, paraErr, resp)
return
}
if len(username) == 0 || len(password) == 0 {
logrus.Errorf("username and password can not be null!")
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, errors.New("Username or password can not be null"), resp)
return
}
errorCode, loginRes, err := services.GetUserService().UserLogin(username, password)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
response.WriteResponse(loginRes, resp)
return
}
//terminate specified hosts of a cluster
// Request
// URL:
// PUT /v1/cluster/<CLUSTER_ID>/hosts
// Header:
// X-Auth-Token
// Except Body:
//{
// "host_ids":["568e23655d5c3d173019f1ba","568e2be45d5c3d173019f1bb","568e2bfd5d5c3d173019f1bc","568e2c335d5c3d173019f1bd"]
//}
//
// Response:
//{
// "success": true
//}
//
func (p *Resource) HostsDeleteHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("HostsDeleteHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
logrus.Errorln("token validation error is %v", err)
response.WriteStatusError(code, err, resp)
return
}
clusterId := req.PathParameter(ParamID)
body := TerminateHostsRequestBody{}
err = json.NewDecoder(req.Request.Body).Decode(&body)
errorCode, err := services.GetClusterService().TerminateHosts(clusterId, body.HostIds, x_auth_token)
if err != nil {
logrus.Errorln("terminate hosts error is %v", err)
response.WriteStatusError(errorCode, err, resp)
return
}
// Write success response
response.WriteSuccess(resp)
return
}
func (p *Resource) ClustersListHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("ClustersListHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
var skip int = queryIntParam(req, "skip", 0)
var limit int = queryIntParam(req, "limit", 0)
var name string = req.QueryParameter("name")
var user_id string = req.QueryParameter("user_id")
var status string = req.QueryParameter("status")
var sort string = req.QueryParameter("sort")
total, clusters, code, err := services.GetClusterService().QueryCluster(name, user_id, status, skip, limit, sort, x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
res := response.QueryStruct{Success: true, Data: clusters}
if c, _ := strconv.ParseBool(req.QueryParameter("count")); c {
res.Count = total
resp.AddHeader("X-Object-Count", strconv.Itoa(total))
}
resp.WriteEntity(res)
return
}
// UserUpdateHandler parses the http request and updata a exist user.
// Usage :
// PUT /v1/user/{ParamID}
// Params :
// ParamID : storage identifier of user
// If successful,response code will be set to 201.
func (p *Resource) UserUpdateHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("UserUpdateHanlder is called!")
token := req.HeaderParameter("X-Auth-Token")
id := req.PathParameter(ParamID)
if len(id) <= 0 {
logrus.Warnln("user id should not be null for update operation")
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, errors.New("user id should not be null for update operation"), resp)
return
}
newuser := entity.User{}
// Populate the user data
err := json.NewDecoder(req.Request.Body).Decode(&newuser)
if err != nil {
logrus.Errorf("convert body to user failed, error is %v", err)
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, err, resp)
return
}
created, id, errorCode, err := services.GetUserService().UserUpdate(token, newuser, id)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
p.successUpdate(id, created, req, resp)
}
func (p *Resource) ClusterCreateHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("ClusterCreateHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
// Stub an acluster to be populated from the body
cluster := entity.Cluster{}
err = json.NewDecoder(req.Request.Body).Decode(&cluster)
if err != nil {
logrus.Errorf("convert body to cluster failed, error is %v", err)
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, err, resp)
return
}
newCluster, code, err := services.GetClusterService().Create(cluster, x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
res := response.QueryStruct{Success: true, Data: newCluster}
resp.WriteEntity(res)
return
}
func (p *Resource) CreateClusterHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("CreateClusterHandler is called!")
// Stub an repairpolicy to be populated from the body
request := entity.Request{}
// Populate the user data
err := json.NewDecoder(req.Request.Body).Decode(&request)
logrus.Infof("Request is %v", request)
logrus.Infof("ProviderInfo is %v", request.ProviderInfo)
logrus.Infof("AwsEC2Info is %v", request.ProviderInfo.AwsEC2Info)
if err != nil {
logrus.Errorf("convert body to request failed, error is %v", err)
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, err, resp)
return
}
servers, code, err := services.GetDeployService().CreateCluster(request)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
res := response.Response{Success: true, Data: servers}
resp.WriteEntity(res)
return
}
// TokenCreateHandler parses the http request and create a new user token.
// Usage :
// POST /v1/token
// If successful,response code will be set to 201.
func (p *Resource) TokenCreateHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("TokenCreateHandler is called!")
doc := bson.M{}
decoder := json.NewDecoder(req.Request.Body)
err := decoder.Decode(&doc)
if err != nil {
logrus.Errorf("decode credential err is %v", err)
response.WriteStatusError(services.TOKEN_ERROR_CREATE, err, resp)
return
}
username, passwd, tenant, paraErr := tokenCreateParamCheck(doc)
if paraErr != nil {
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, paraErr, resp)
return
}
ret, errorCode, err := services.GetTokenService().TokenCreate(username, passwd, tenant)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
response.WriteResponse(ret, resp)
return
}
func (p *Resource) DeleteClusterHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("DeleteClusterHandler is called!")
// Stub an repairpolicy to be populated from the body
request := entity.DeleteRequest{}
// Populate the user data
err := json.NewDecoder(req.Request.Body).Decode(&request)
logrus.Infof("Username is %v", request.UserName)
logrus.Infof("Cluster is %v", request.ClusterName)
logrus.Infof("Servers is %v", request.Servers)
if err != nil {
logrus.Errorf("convert body to DeleteClusterRequest failed, error is %v", err)
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, err, resp)
return
}
code, err := services.GetDeployService().DeleteCluster(request.UserName, request.ClusterName, request.Servers)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
res := response.Response{Success: true}
resp.WriteEntity(res)
return
}
func (p *Resource) AddNodesHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("AddNodesHandler is called!")
// Stub an repairpolicy to be populated from the body
request := entity.AddNodeRequest{}
// Populate the user data
err := json.NewDecoder(req.Request.Body).Decode(&request)
logrus.Infof("Username is %v", request.UserName)
logrus.Infof("Cluster is %v", request.ClusterName)
logrus.Infof("CreateNumber is %v", request.CreateNumber)
if err != nil {
logrus.Errorf("convert body to AddNodesRequest failed, error is %v", err)
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, err, resp)
return
}
servers, code, err := services.GetDeployService().CreateNode(request)
var res response.Response
if err != nil {
errObj := response.Error{Code: code, ErrorMsg: fmt.Sprintf("%v", err)}
res = response.Response{Success: true, Error: &errObj, Data: servers}
} else {
res = response.Response{Success: true, Data: servers}
}
resp.WriteEntity(res)
return
}
func (p *Resource) HostsListHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("HostsListHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
logrus.Errorln("token validation error is %v", err)
response.WriteStatusError(code, err, resp)
return
}
clusterId := req.PathParameter(ParamID)
var skip, limit int64
if param_skip := req.QueryParameter("skip"); len(param_skip) > 0 {
skip, err = strconv.ParseInt(param_skip, 10, 0)
if err != nil {
response.WriteStatusError("E12002", err, resp)
return
}
}
if param_limit := req.QueryParameter("limit"); len(param_limit) > 0 {
limit, err = strconv.ParseInt(req.QueryParameter("limit"), 10, 0)
if err != nil {
response.WriteStatusError("E12002", err, resp)
return
}
}
var status string = req.QueryParameter("status")
total, hosts, errorCode, err := services.GetHostService().QueryHosts(clusterId, int(skip), int(limit), status, x_auth_token)
if err != nil {
logrus.Errorln("list hosts error is %v", err)
response.WriteStatusError(errorCode, err, resp)
return
}
res := response.QueryStruct{Success: true, Data: hosts}
if c, _ := strconv.ParseBool(req.QueryParameter("count")); c {
res.Count = total
resp.AddHeader("X-Object-Count", strconv.Itoa(total))
}
resp.WriteEntity(res)
return
}
// TokenValidateHandler parses the http request and return valid user token.
// Usage :
// GET /v1/token
// If successful,response code will be set to 201.
func (p *Resource) TokenValidateHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("TokenValidateHandler is called!")
var tokenId = req.QueryParameter("token")
if len(tokenId) <= 0 {
logrus.Errorln("invalie parameter! tokenId can not be null for token validation")
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, errors.New("invalie parameter! tokenId can not be null for token validation"), resp)
return
}
errorCode, err := services.GetTokenService().TokenValidate(tokenId)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
response.WriteSuccess(resp)
}
// UserDeleteHandler parses the http request and delete a user.
// Usage :
// DELETE /v1/user/{ParamID}
// Params :
// ParamID : storage identifier of user
// If successful,response code will be set to 201.
func (p *Resource) UserDeleteHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("UserDeleteHandler is called!")
token := req.HeaderParameter("X-Auth-Token")
id := req.PathParameter(ParamID)
if len(id) <= 0 {
logrus.Warnln("user id should not be null for delete operation")
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, errors.New("user id should not be null for delete operation"), resp)
return
}
errorCode, err := services.GetUserService().UserDelete(token, id)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
response.WriteSuccess(resp)
}
// UserChangePasswdHandler parses the http request and change
// password of an exist user.
// Usage :
// PUT v1/user/changepassword/{ParamID}
// Params :
// ParamID : storage identifier of user
// If successful,response code will be set to 201.
func (p *Resource) UserChangePasswdHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("UserChangePasswdHandler is called!")
token := req.HeaderParameter("X-Auth-Token")
id := req.PathParameter(ParamID)
if len(id) <= 0 {
logrus.Warnln("user id should not be null for change password operation")
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, errors.New("user id should not be null for update operation"), resp)
return
}
document := bson.M{}
decoder := json.NewDecoder(req.Request.Body)
err := decoder.Decode(&document)
if err != nil {
logrus.Errorf("decode change password object err is %v", err)
response.WriteStatusError(services.COMMON_ERROR_INTERNAL, err, resp)
return
}
document, err = mejson.Unmarshal(document)
if err != nil {
logrus.Errorf("unmarshal change password obejct err is %v", err)
response.WriteStatusError(services.COMMON_ERROR_INTERNAL, err, resp)
return
}
password := document["password"]
newpwd1 := document["newpassword"]
newpwd2 := document["confirm_newpassword"]
if password == nil || newpwd1 == nil || newpwd2 == nil {
logrus.Errorln("invalid parameter! password and newpassword field should not be null")
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, errors.New("invalid parameter!password, newpassword and confirm_newpassword should not be null!"), resp)
return
}
created, errorCode, err := services.GetUserService().UserChangePassword(token, id, password.(string), newpwd1.(string), newpwd2.(string))
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
p.successUpdate(id, created, req, resp)
}
func (p *Resource) TokenDetailHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("TokenDetailHandler is called!")
token := req.HeaderParameter("X-Auth-Token")
id := req.PathParameter(ParamID)
if len(id) <= 0 {
logrus.Warnln("token id should not be null for token detail operation")
response.WriteStatusError(services.TOKEN_ERROR_GET, errors.New("token id should not be null for get user operation"), resp)
return
}
ret, errorCode, err := services.GetTokenService().TokenDetail(token, id)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
response.WriteResponse(ret, resp)
}
func (p *Resource) UserClusterDeleteHandler(req *restful.Request, resp *restful.Response) {
logrus.Infoln("UserClusterDeleteHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
userId := req.QueryParameter("user_id")
code, err = services.GetClusterService().DeleteByUserId(userId, x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
// Write success response
response.WriteSuccess(resp)
return
}
//Send cluster owner an email of endpoint
func (p *Resource) EmailSendHandler(req *restful.Request, resp *restful.Response) {
logrus.Infoln("EmailSendHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
clusterId := req.PathParameter(ParamID)
errorCode, err := services.GetEmailService().SendClusterDeployedEmail(clusterId, x_auth_token)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
// Write success response
response.WriteSuccess(resp)
return
}
func (p *Resource) UserValidateHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("UserValidateHandler is called!")
token := req.HeaderParameter("X-Auth-Token")
username := req.QueryParameter("username")
if len(username) == 0 {
logrus.Warnln("username should not be null")
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, errors.New("username should not be null"), resp)
return
}
logrus.Infof("username is %v", username)
logrus.Infof("start to test username")
errorCode, _, err := services.GetUserService().Validate(username, token)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
response.WriteSuccess(resp)
}
//check username and clustername
func (p *Resource) ClusterNameCheckHandler(req *restful.Request, resp *restful.Response) {
logrus.Infoln("ClusterNameCheckHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
userId := req.QueryParameter("userid")
clusterName := req.QueryParameter("clustername")
errorCode, err := services.GetClusterService().CheckClusterName(userId, clusterName, x_auth_token)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
// Write success response
response.WriteSuccess(resp)
return
}
// RoleListHandler parses the http request and return the exist roles.
// Usage :
// GET /v1/role
// If successful,response code will be set to 201.
func (p *Resource) RoleListHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("RoleListHandler is called!")
token := req.HeaderParameter("X-Auth-Token")
ret, count, errorCode, err := services.GetRoleService().RoleList(token)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
p.successList(ret, 0, count, req, resp)
}
func (p *Resource) ClusterGetHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("ClusterGetHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
objectId := req.PathParameter(ParamID)
cluster, code, err := services.GetClusterService().QueryById(objectId, x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
logrus.Debugf("cluster is %v", cluster)
res := response.QueryStruct{Success: true, Data: cluster}
resp.WriteEntity(res)
return
}
// CheckAndGenerateToken parses the http request and registry a new user.
// Usage :
// POST /v1/user/registry
// If successful,response code will be set to 201.
func (p *Resource) UserCreateUserHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("UserCreateUserHandler is called!")
token := req.HeaderParameter("X-Auth-Token")
doc := bson.M{}
decoder := json.NewDecoder(req.Request.Body)
err := decoder.Decode(&doc)
if err != nil {
logrus.Errorf("decode user err is %v", err)
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, err, resp)
return
}
username, email, password, company, paraErr := userRegistryParamCheck(doc)
if paraErr != nil {
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, paraErr, resp)
return
}
if len(email) == 0 || len(password) == 0 || len(username) == 0 {
logrus.Errorln("parameter can not be null!")
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, errors.New("Invalid parameter"), resp)
return
}
userParam := services.UserParam{
UserName: username,
Email: email,
Password: password,
Company: company}
errorCode, userId, err := services.GetUserService().Create(userParam, token)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
p.successUpdate(userId, true, req, resp)
}
// TokenReGenerateHandler parses the http request and generate
// another user's token from current token.
// Usage :
// POST /v1/token/regenerate
// If successful,response code will be set to 201.
func (p *Resource) TokenReGenerateHandler(req *restful.Request, resp *restful.Response) {
logrus.Infoln("TokenReGenerateHandler is called!")
token := req.HeaderParameter("X-Auth-Token")
document := bson.M{}
decoder := json.NewDecoder(req.Request.Body)
err := decoder.Decode(&document)
if err != nil {
logrus.Errorf("decode token generate err is %v", err)
response.WriteStatusError(services.TOKEN_ERROR_CREATE, err, resp)
return
}
document, err = mejson.Unmarshal(document)
if err != nil {
logrus.Errorf("unmarshal token generate err is %v", err)
response.WriteStatusError(services.TOKEN_ERROR_CREATE, err, resp)
return
}
userid := document["user_id"]
tenantid := document["tenant_id"]
if userid == nil || tenantid == nil {
logrus.Errorln("invalid parameter! user and tenant should not be null!")
response.WriteStatusError(services.COMMON_ERROR_INVALIDATE, errors.New("invalid parameter! user and tenant should not be null!"), resp)
return
}
tokenId, errorCode, err := services.GetTokenService().TokenReGenerate(token, userid.(string), tenantid.(string))
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
response.WriteResponse(tokenId, resp)
return
}
func (p *Resource) ClustersDeleteHandler(req *restful.Request, resp *restful.Response) {
logrus.Infoln("UserClusterDeleteHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
response.WriteStatusError(code, err, resp)
return
}
body := DeleteClustersRequestBody{}
err = json.NewDecoder(req.Request.Body).Decode(&body)
errorCode, err := services.GetClusterService().DeleteClusters(body.ClusterIds, x_auth_token)
if err != nil {
logrus.Errorln("delete clusters error , [%v]", err)
response.WriteStatusError(errorCode, err, resp)
return
}
// Write success response
response.WriteSuccess(resp)
return
}
func (p *Resource) TenantIdHandler(req *restful.Request, resp *restful.Response) {
logrus.Infoln("TenantIdHandler is called!")
token := req.HeaderParameter("X-Auth-Token")
userId := req.QueryParameter("userId")
ret, errorCode, err := services.GetTenantService().GetTenantId(token, userId)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
response.WriteResponse(ret, resp)
}
func (p *Resource) HostGetHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("HostGetHandler is called!")
x_auth_token := req.HeaderParameter("X-Auth-Token")
code, err := services.TokenValidation(x_auth_token)
if err != nil {
logrus.Errorln("token validation error is %v", err)
response.WriteStatusError(code, err, resp)
return
}
hostId := req.PathParameter(ParamHostID)
host, code, err := services.GetHostService().QueryById(hostId, x_auth_token)
if err != nil {
logrus.Errorln("get host error is %v", err)
response.WriteStatusError(code, err, resp)
return
}
res := response.QueryStruct{Success: true, Data: host}
resp.WriteEntity(res)
return
}
// UserListHandler parses the http request and return the user items.
// Usage :
// GET /v1/user
// GET /v1/user/{ParamID}
// Params :
// ParamID : storage identifier of user
// If successful,response code will be set to 201.
func (p *Resource) UserListHandler(req *restful.Request, resp *restful.Response) {
logrus.Infof("UserListHandler is called!")
token := req.HeaderParameter("X-Auth-Token")
limitnum := queryIntParam(req, "limit", 10)
skipnum := queryIntParam(req, "skip", 0)
sort := req.QueryParameter("sort")
ret, count, errorCode, err := services.GetUserService().UserList(token, limitnum, skipnum, sort)
if err != nil {
response.WriteStatusError(errorCode, err, resp)
return
}
p.successList(ret, limitnum, count, req, resp)
}