init engine

Author: LockGit

command/build.go

@@ -17,7 +17,7 @@ var CmdList = []string{
 }
 
 func buildCmd() (h handler.Handler, e error) {
-	exec := handler.Handler(handler.HandlerFunc(func(ctx *handler.Context) {}))
+	exec := handler.Handler(handler.HandleFunc(func(ctx *handler.Context) {}))
 	for i := len(CmdList) - 1; i >= 0; i-- {
 		name := CmdList[i]
 		if setup := Get(name); setup != nil {
@@ -32,13 +32,16 @@ func buildCmd() (h handler.Handler, e error) {
 	return exec, nil
 }
 
-func GetCmdExecutor() handler.Handler {
+func Build() (err error) {
 	once.Do(func() {
-		bc, err := buildCmd()
+		cmdExecutor, err = buildCmd()
 		if err != nil {
-			panic("init() buildCmd err:" + err.Error())
+			return
 		}
-		cmdExecutor = bc
 	})
+	return
+}
+
+func GetCmdExecutor() handler.Handler {
 	return cmdExecutor
 }

command/combine/combine.go

@@ -1,9 +1,9 @@
 package combine
 
 import (
-	"log"
 	"net/http"
 	"xhttp/command"
+	"xhttp/command/combine/process"
 	"xhttp/handler"
 )
 
@@ -23,12 +23,16 @@ type Combine struct {
 }
 
 func (c *Combine) ServerHTTP(ctx *handler.Context) {
-	if c.NextHandler != nil {
-		defer c.NextHandler.ServerHTTP(ctx)
+	if c.Next() != nil {
+		defer c.Next().ServerHTTP(ctx)
 	}
-	log.Println("Combine:", ctx.Request.RequestURI)
-	ctx.Response.WriteHeader(http.StatusOK)
-	ctx.Response.Write([]byte("ok:" + ctx.Request.RequestURI))
+	p, ok := process.DefaultProcess[ctx.API.ExecType]
+	if !ok {
+		ctx.Response.WriteHeader(http.StatusInternalServerError)
+		ctx.Response.Write([]byte("no support exec method"))
+		return
+	}
+	p.Exec(ctx)
 }
 
 func (c *Combine) Next() handler.Handler {

command/combine/process/http.go

@@ -0,0 +1,102 @@
+package process
+
+import (
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+	"xhttp/storage"
+)
+
+var HttpRequestFactory = map[string]IHttp{}
+
+func init() {
+	register(http.MethodPost, &PostJson{})
+	register(http.MethodGet, &Get{})
+}
+
+type IHttp interface {
+	DoRequest(api *storage.APIChildren, requestParams map[string]interface{}) (v string, err error)
+}
+
+func register(method string, o IHttp) {
+	if _, ok := HttpRequestFactory[method]; !ok {
+		HttpRequestFactory[method] = o
+	}
+}
+
+type PostJson struct {
+}
+
+func (p *PostJson) DoRequest(api *storage.APIChildren, requestParams map[string]interface{}) (v string, err error) {
+	url := api.Url
+	var bs []byte
+	bs, err = json.Marshal(requestParams)
+	if err != nil {
+		return
+	}
+	var req *http.Request
+	req, err = http.NewRequest(strings.ToUpper(api.Method), url, strings.NewReader(string(bs)))
+	c := http.Client{
+		Timeout: time.Duration(api.Timeout) * time.Second,
+	}
+	var resp *http.Response
+	resp, err = c.Do(req)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	var bodyBytes []byte
+	bodyBytes, err = ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	return string(bodyBytes), nil
+}
+
+type Get struct {
+}
+
+func (g *Get) DoRequest(api *storage.APIChildren, requestParams map[string]interface{}) (v string, err error) {
+	url := api.Url
+	var req *http.Request
+	req, err = http.NewRequest(strings.ToUpper(api.Method), url, nil)
+	q := req.URL.Query()
+	for k, val := range requestParams {
+		q.Add(k, val.(string))
+	}
+	req.URL.RawQuery = q.Encode()
+	c := http.Client{
+		Timeout: time.Duration(api.Timeout) * time.Second,
+	}
+	var resp *http.Response
+	log.Println("req.URL:::::::", req.URL, req.Method)
+	resp, err = c.Do(req)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	var bodyBytes []byte
+	bodyBytes, err = ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	return string(bodyBytes), nil
+}
+
+func execRequest(api *storage.APIChildren, requestParams map[string]interface{}, data *Response) (err error) {
+	method := strings.ToUpper(api.Method)
+	if exec, ok := HttpRequestFactory[method]; ok {
+		var val string
+		val, err = exec.DoRequest(api, requestParams)
+		if err != nil {
+			return
+		}
+		data.Set(api.Name, val)
+		return
+	}
+	return errors.New("no support method:" + method)
+}

command/combine/process/iprocess.go

@@ -0,0 +1,47 @@
+package process
+
+import (
+	"encoding/json"
+	"sync"
+	"xhttp/handler"
+)
+
+type IProcess interface {
+	Name() string
+	Exec(ctx *handler.Context)
+}
+
+var DefaultProcess = map[string]IProcess{}
+
+func Register(p IProcess) {
+	if _, ok := DefaultProcess[p.Name()]; !ok {
+		DefaultProcess[p.Name()] = p
+	}
+}
+
+type Response struct {
+	Data map[string]interface{}
+	mu   sync.Mutex
+}
+
+func NewResponse() *Response {
+	return &Response{
+		Data: make(map[string]interface{}),
+	}
+}
+
+func (r *Response) Set(k string, v interface{}) {
+	r.mu.Lock()
+	r.Data[k] = v
+	r.mu.Unlock()
+}
+
+func (r *Response) Get(k string) (v interface{}, ok bool) {
+	v, ok = r.Data[k]
+	return
+}
+
+func (r *Response) ToBytes() (bs []byte) {
+	bs, _ = json.MarshalIndent(r.Data, "", "  ")
+	return
+}

command/combine/process/parallel_exec.go

@@ -0,0 +1,51 @@
+package process
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"sync"
+	"xhttp/command/combine/process/params"
+	"xhttp/handler"
+	"xhttp/storage"
+)
+
+func init() {
+	Register(NewParallelProcess())
+}
+
+type ParallelProcess struct {
+}
+
+func NewParallelProcess() *ParallelProcess {
+	return &ParallelProcess{}
+}
+
+func (p *ParallelProcess) Name() string {
+	return "parallel"
+}
+
+func (p *ParallelProcess) Exec(ctx *handler.Context) {
+	data := NewResponse()
+	wg := sync.WaitGroup{}
+	for _, apiChild := range ctx.GetCurAPIChildren() {
+		log.Println("start exec api:", apiChild.Name)
+		requestParams := make(map[string]interface{})
+		for _, param := range apiChild.Params {
+			v, _ := params.GetParamsValue(ctx, param)
+			requestParams[param.Name] = v
+		}
+		wg.Add(1)
+		go func(api *storage.APIChildren) {
+			if err := execRequest(api, requestParams, data); err != nil {
+				log.Println(fmt.Sprintf("url:%s,child:%s,request err:%s", ctx.API.Url, apiChild.Name, err.Error()))
+			}
+			wg.Done()
+		}(apiChild)
+	}
+	wg.Wait()
+
+	ctx.Response.Header().Add("Content-Type", "application/json")
+	ctx.Response.WriteHeader(http.StatusOK)
+	ctx.Response.Write(data.ToBytes())
+}

command/combine/process/params/body.go

@@ -0,0 +1,30 @@
+package params
+
+import (
+	"encoding/json"
+	"strings"
+	"xhttp/handler"
+)
+
+func init() {
+	Register("$.body", &Body{})
+}
+
+type Body struct {
+}
+
+func (b *Body) Get(ctx *handler.Context, name string) (v string, has bool) {
+	ct := ctx.Request.Header.Get("Content-Type")
+	if strings.HasPrefix(strings.ToLower(ct), "application/x-www-form-urlencoded") {
+		return ctx.Request.Form.Get(name), ctx.Request.Form.Has(name)
+	}
+	if strings.HasPrefix(strings.ToLower(ct), "application/json") {
+		decoder := json.NewDecoder(ctx.Request.Body)
+		var params map[string]string
+		if err := decoder.Decode(&params); err == nil {
+			v, has = params[name]
+			return
+		}
+	}
+	return
+}

command/combine/process/params/cookie.go

@@ -0,0 +1,20 @@
+package params
+
+import "xhttp/handler"
+
+func init() {
+	Register("$.cookie", &Cookie{})
+}
+
+type Cookie struct {
+}
+
+func (c *Cookie) Get(ctx *handler.Context, name string) (v string, has bool) {
+	cookies := ctx.Request.Cookies()
+	for _, cookie := range cookies {
+		if name == cookie.Name {
+			return cookie.Value, true
+		}
+	}
+	return v, false
+}

command/combine/process/params/header.go

@@ -0,0 +1,17 @@
+package params
+
+import "xhttp/handler"
+
+func init() {
+	Register("$.header", &Header{})
+}
+
+type Header struct {
+}
+
+func (h *Header) Get(ctx *handler.Context, name string) (v string, has bool) {
+	if len(ctx.Request.Header.Values(name)) > 0 {
+		has = true
+	}
+	return ctx.Request.Header.Get(name), has
+}

command/combine/process/params/iparams.go

@@ -0,0 +1,29 @@
+package params
+
+import (
+	"xhttp/handler"
+	"xhttp/storage"
+)
+
+var ParamsFactory = map[string]IParams{}
+
+type IParams interface {
+	Get(ctx *handler.Context, name string) (v string, has bool)
+}
+
+func Register(source string, p IParams) {
+	if _, ok := ParamsFactory[source]; !ok {
+		ParamsFactory[source] = p
+	}
+}
+
+func GetParamsValue(ctx *handler.Context, param *storage.Param) (v string, hit bool) {
+	if factory, ok := ParamsFactory[param.Source]; ok {
+		val, has := factory.Get(ctx, param.Name)
+		if !has {
+			val = param.DefaultValue
+		}
+		return val, true
+	}
+	return param.DefaultValue, false
+}

command/combine/process/params/query.go

@@ -0,0 +1,15 @@
+package params
+
+import "xhttp/handler"
+
+func init() {
+	Register("$.query", &Query{})
+}
+
+type Query struct {
+}
+
+func (q Query) Get(ctx *handler.Context, name string) (v string, has bool) {
+	v = ctx.Request.URL.Query().Get(name)
+	return v, ctx.Request.URL.Query().Has(name)
+}