Merge pull request #47 from FlowCI/develop

0.21.21

api/client.go

@@ -37,11 +37,11 @@ var (
 
 type (
 	Client interface {
-		Connect(*domain.AgentInit) error
+		Connect(*domain.AgentInit) (*domain.AgentConfig, error)
 		ReConn() <-chan struct{}
 
 		UploadLog(filePath string) error
-		ReportProfile(*domain.Resource) error
+		ReportProfile(profile *domain.AgentProfile) error
 
 		GetCmdIn() <-chan []byte
 		SendCmdOut(out domain.CmdOut) error
@@ -81,10 +81,10 @@ type (
 	}
 )
 
-func (c *client) Connect(init *domain.AgentInit) error {
+func (c *client) Connect(init *domain.AgentInit) (*domain.AgentConfig, error) {
 	u, err := url.Parse(c.server)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	u.Scheme = "ws"
@@ -103,37 +103,33 @@ func (c *client) Connect(init *domain.AgentInit) error {
 	// build connection
 	c.conn, _, err = dialer.Dial(u.String(), header)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	c.conn.SetReadLimit(bufferSize)
 	c.setConnState(connStateConnected)
 
 	// send init connect event
-	_, err = c.sendMessageWithResp(eventConnect, init)
+	resp := &domain.AgentConfigResponse{}
+	err = c.sendMessageWithResp(eventConnect, init, resp)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// start to read message
 	go c.readMessage()
 	go c.consumePendingMessage()
 
 	util.LogInfo("Agent is connected to server %s", c.server)
-	return nil
+	return resp.Data, nil
 }
 
 func (c *client) ReConn() <-chan struct{} {
 	return c.reConn
 }
 
-func (c *client) ReportProfile(r *domain.Resource) (err error) {
-	body, err := json.Marshal(r)
-	if err != nil {
-		return
-	}
-
-	_, err = c.send("POST", "profile", util.HttpMimeJson, bytes.NewBuffer(body))
+func (c *client) ReportProfile(r *domain.AgentProfile) (err error) {
+	_ = c.sendMessageWithJson(eventProfile, r)
 	return
 }
 
@@ -291,25 +287,39 @@ func (c *client) GetSecret(name string) (secret domain.Secret, err error) {
 	out, err := ioutil.ReadAll(resp.Body)
 	util.PanicIfErr(err)
 
-	base := &domain.SecretBase{}
-	err = json.Unmarshal(out, base)
+	secretResp, err := c.parseResponse(out, &domain.SecretResponse{})
+	util.PanicIfErr(err)
+
+	body := secretResp.(*domain.SecretResponse)
+	util.PanicIfNil(body.Data, "secret data")
+
+	base := body.Data
+	baseRaw := &domain.SecretResponseRaw{}
+	err = json.Unmarshal(out, baseRaw)
 	util.PanicIfErr(err)
 
 	if base.Category == domain.SecretCategoryAuth {
 		auth := &domain.AuthSecret{}
-		err = json.Unmarshal(out, auth)
+		err = json.Unmarshal(baseRaw.Raw, auth)
 		util.PanicIfErr(err)
 		return auth, nil
 	}
 
 	if base.Category == domain.SecretCategorySshRsa {
 		rsa := &domain.RSASecret{}
-		err = json.Unmarshal(out, rsa)
+		err = json.Unmarshal(baseRaw.Raw, rsa)
 		util.PanicIfErr(err)
 		return rsa, nil
 	}
 
-	return nil, fmt.Errorf("unsupport secret type")
+	if base.Category == domain.SecretCategoryToken {
+		token := &domain.TokenSecret{}
+		err = json.Unmarshal(baseRaw.Raw, token)
+		util.PanicIfErr(err)
+		return token, nil
+	}
+
+	return nil, fmt.Errorf("secret '%s' category '%s' is unsupported", base.GetName(), base.GetCategory())
 }
 
 func (c *client) Close() {
@@ -454,7 +464,7 @@ func (c *client) sendMessageWithBytes(event string, body []byte) error {
 	return nil
 }
 
-func (c *client) sendMessageWithResp(event string, msg interface{}) (resp *domain.Response, out error) {
+func (c *client) sendMessageWithResp(event string, msg interface{}, resp domain.ResponseMessage) (out error) {
 	defer util.RecoverPanic(func(e error) {
 		out = e
 	})
@@ -468,10 +478,8 @@ func (c *client) sendMessageWithResp(event string, msg interface{}) (resp *domai
 	_, data, err := c.conn.ReadMessage()
 	util.PanicIfErr(err)
 
-	message, err := c.parseResponse(data, &domain.Response{})
+	_, err = c.parseResponse(data, resp)
 	util.PanicIfErr(err)
-
-	resp = message.(*domain.Response)
 	return
 }
 

api/const.go

@@ -2,6 +2,7 @@ package api
 
 const (
 	eventConnect  = "connect___"
+	eventProfile  = "profile___"
 	eventCmdOut   = "cmd_out___"
 	eventShellLog = "slog______"
 	eventTtyLog   = "tlog______"