openstack 修改兼容多集群热加载

internal/logic/addsecuritygrouptoserverlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -33,28 +31,31 @@ func (l *AddSecurityGroupToServerLogic) AddSecurityGroupToServer(in *openstack.A
 	var resp openstack.AddSecurityGroupToServerResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	// token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackComputeUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 
 }

internal/logic/bulkcreatenetworkslogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -39,22 +37,25 @@ func (l *BulkCreateNetworksLogic) BulkCreateNetworks(in *openstack.BulkCreateNet
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
 	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/networks", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	//token := common.GetToken()
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/networks", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/changeadministrativepasswordlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -33,27 +31,30 @@ func (l *ChangeAdministrativePasswordLogic) ChangeAdministrativePassword(in *ope
 	var resp openstack.ChangeAdministrativePasswordResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackComputeUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createfirewallgrouplogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -33,27 +31,27 @@ func (l *CreateFirewallGroupLogic) CreateFirewallGroup(in *openstack.CreateFirew
 	var resp openstack.CreateFirewallGroupResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/fwaas/firewall_groups", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	//statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/fwaas/firewall_groups", payload, token)
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createfirewallpolicylogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -33,27 +31,30 @@ func (l *CreateFirewallPolicyLogic) CreateFirewallPolicy(in *openstack.CreateFir
 	var resp openstack.CreateFirewallPolicyResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/fwaas/firewall_policies", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/fwaas/firewall_policies", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createfirewallrulelogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -33,27 +31,30 @@ func (l *CreateFirewallRuleLogic) CreateFirewallRule(in *openstack.CreateFirewal
 	var resp openstack.CreateFirewallRuleResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/fwaas/firewall_rules", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/fwaas/firewall_rules", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createflavorlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -33,13 +31,16 @@ func (l *CreateFlavorLogic) CreateFlavor(in *openstack.CreateFlavorReq) (*openst
 	var resp openstack.CreateFlavorResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackComputeUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/flavors", payload, token)
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
+	return &resp, nil
+	/*statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/flavors", payload, token)
 	if err != nil {
 		return nil, err
 	}
@@ -55,5 +56,5 @@ func (l *CreateFlavorLogic) CreateFlavor(in *openstack.CreateFlavorReq) (*openst
 		resp.Code = 400
 		resp.Msg = "Failure"
 	}
-	return &resp, nil
+	return &resp, nil*/
 }

internal/logic/createfloatingiplogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -33,13 +31,16 @@ func (l *CreateFloatingIPLogic) CreateFloatingIP(in *openstack.CreateFloatingIPR
 	var resp openstack.CreateFloatingIPResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/floatingips", payload, token)
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
+	return &resp, nil
+	/*statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/floatingips", payload, token)
 	if err != nil {
 		return nil, err
 	}
@@ -55,5 +56,5 @@ func (l *CreateFloatingIPLogic) CreateFloatingIP(in *openstack.CreateFloatingIPR
 		resp.Code = 400
 		resp.Msg = "Failure"
 	}
-	return &resp, nil
+	return &resp, nil*/
 }

internal/logic/createimagelogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -39,8 +37,11 @@ func (l *CreateImageLogic) CreateImage(in *openstack.CreateImageReq) (*openstack
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackImageUrl
 	openstackUrl := platform.OpenstackImageUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2/images", payload, token)
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
+	return &resp, nil
+	//token := common.GetToken()
+	/*statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2/images", payload, token)
 	if err != nil {
 		return nil, err
 	}
@@ -56,5 +57,5 @@ func (l *CreateImageLogic) CreateImage(in *openstack.CreateImageReq) (*openstack
 		resp.Code = 400
 		resp.Msg = "Failure"
 	}
-	return &resp, nil
+	return &resp, nil*/
 }

internal/logic/createnetworklogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -32,28 +30,31 @@ func (l *CreateNetworkLogic) CreateNetwork(in *openstack.CreateNetworkReq) (*ope
 	var resp openstack.CreateNetworkResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/networks", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 201 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 201 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/networks", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 201 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 201 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createnetworksegmentrangelogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -34,27 +32,30 @@ func (l *CreateNetworkSegmentRangeLogic) CreateNetworkSegmentRange(in *openstack
 	var resp openstack.CreateNetworkSegmentRangeResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/network_segment_ranges", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/network_segment_ranges", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createnodelogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -31,7 +29,7 @@ func (l *CreateNodeLogic) CreateNode(in *openstack.CreateNodeReq) (*openstack.Cr
 	// todo: add your logic here and delete this line
 	var resp openstack.CreateNodeResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	token := common.GetToken()
+	//token := common.GetToken()
 	reqByte, err := json.Marshal(in)
 	if err != nil {
 		return nil, err
@@ -39,21 +37,24 @@ func (l *CreateNodeLogic) CreateNode(in *openstack.CreateNodeReq) (*openstack.Cr
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
 	openstackUrl := platform.OpenstackComputeUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v1/nodes", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 201 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 201 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v1/nodes", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 201 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 201 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createportlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -34,27 +32,30 @@ func (l *CreatePortLogic) CreatePort(in *openstack.CreatePortReq) (*openstack.Cr
 	var resp openstack.CreatePortResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/ports", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/ports", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createrouterlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -34,27 +32,30 @@ func (l *CreateRouterLogic) CreateRouter(in *openstack.CreateRouterReq) (*openst
 	var resp openstack.CreateRouterResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/routers", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/routers", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createsecuritygrouplogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -33,28 +31,31 @@ func (l *CreateSecurityGroupLogic) CreateSecurityGroup(in *openstack.CreateSecur
 	var resp openstack.CreateSecurityGroupResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/security-groups", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
-
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/security-groups", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+
+		return &resp, nil*/
 }

internal/logic/createsecuritygrouprulelogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -33,27 +31,30 @@ func (l *CreateSecurityGroupRuleLogic) CreateSecurityGroupRule(in *openstack.Cre
 	var resp openstack.CreateSecurityGroupRuleResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/security-group-rules", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/security-group-rules", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createserverlogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"strings"
 
 	"github.com/zeromicro/go-zero/core/logx"
@@ -32,29 +30,32 @@ func (l *CreateServerLogic) CreateServer(in *openstack.CreateServerReq) (*openst
 	var resp openstack.CreateServerResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
 	openstackUrl := platform.OpenstackComputeUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 
 }

internal/logic/createsubnetlogic.go

@@ -3,9 +3,7 @@ package logic
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"strings"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,27 +31,30 @@ func (l *CreateSubnetLogic) CreateSubnet(in *openstack.CreateSubnetReq) (*openst
 	var resp openstack.CreateSubnetResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackNetworkUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/subnets", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 201 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 201 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/v2.0/subnets", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 201 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 201 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createvolumelogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -35,25 +33,28 @@ func (l *CreateVolumeLogic) CreateVolume(in *openstack.CreateVolumeReq) (*openst
 	if err != nil {
 		return nil, err
 	}
-	token := common.GetToken()
+	//token := common.GetToken()
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
 	openstackUrl := platform.OpenstackVolumev2Url
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/volumes", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/volumes", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/createvolumetypeslogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -38,22 +36,25 @@ func (l *CreateVolumeTypesLogic) CreateVolumeTypes(in *openstack.CreateVolumeTyp
 	payload := strings.NewReader(string(reqByte))
 	//penstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
 	openstackUrl := platform.OpenstackVolumev2Url
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/types", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	//token := common.GetToken()
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/types", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletefirewallgrouplogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeleteFirewallGroupLogic) DeleteFirewallGroup(in *openstack.DeleteFirew
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteFirewallGroupResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/fwaas/firewall_groups/"+in.FirewallGroupId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	reqByte, err := json.Marshal(in)
+	//token := common.GetToken()
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/fwaas/firewall_groups/"+in.FirewallGroupId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletefirewallpolicylogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeleteFirewallPolicyLogic) DeleteFirewallPolicy(in *openstack.DeleteFir
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteFirewallPolicyResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/fwaas/firewall_policies/"+in.FirewallPolicyId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	//token := common.GetToken()
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/fwaas/firewall_policies/"+in.FirewallPolicyId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletefirewallrulelogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeleteFirewallRuleLogic) DeleteFirewallRule(in *openstack.DeleteFirewal
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteFirewallRuleResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/fwaas/firewall_rules/"+in.FirewallRuleId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	//token := common.GetToken()
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/fwaas/firewall_rules/"+in.FirewallRuleId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deleteflavorlogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeleteFlavorLogic) DeleteFlavor(in *openstack.DeleteFlavorReq) (*openst
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteFlavorResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackImageUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/flavors/"+in.FlavorId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackImageUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	//token := common.GetToken()
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/flavors/"+in.FlavorId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletefloatingiplogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeleteFloatingIPLogic) DeleteFloatingIP(in *openstack.DeleteFloatingIPR
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteFloatingIPResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/floatingips/"+in.FloatingipId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	//token := common.GetToken()
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/floatingips/"+in.FloatingipId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deleteimagelogic.go

@@ -1,17 +1,13 @@
 package logic
 
 import (
+	"bytes"
+	"context"
+	"github.com/zeromicro/go-zero/core/logx"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-
-	"context"
-	"fmt"
 	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type DeleteImageLogic struct {
@@ -32,24 +28,31 @@ func (l *DeleteImageLogic) DeleteImage(in *openstack.DeleteImageReq) (*openstack
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteImageResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackImageUrl
-	openstackUrl := platform.OpenstackImageUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2/images/"+in.ImageId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackImageUrl
+	openstackUrl := platform.OpenstackImageUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// token := common.GetToken()
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2/images/"+in.ImageId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletenetworklogic.go

@@ -1,16 +1,13 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
+	"github.com/zeromicro/go-zero/core/logx"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type DeleteNetworkLogic struct {
@@ -31,25 +28,32 @@ func (l *DeleteNetworkLogic) DeleteNetwork(in *openstack.DeleteNetworkReq) (*ope
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteNetworkResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/networks/"+in.NetworkId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
-  //删除网络id
+	openstackUrl := platform.OpenstackNetworkUrl
+	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
+	// token := common.GetToken()
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/networks/"+in.NetworkId, strings.NewReader(``), token)
+			if err != nil {
+				return nil, err
+			}
+			if statusCode == 204 {
+				err := json.Unmarshal(body, &resp)
+				if err != nil {
+					fmt.Println(err)
+				}
+				resp.Code = 200
+				resp.Msg = "Success"
+			} else if statusCode != 204 {
+				json.Unmarshal(body, &resp)
+				resp.Code = 400
+				resp.Msg = "Failure"
+			}
+		  //删除网络id
+			return &resp, nil*/
 }

internal/logic/deletenetworksegmentrangeslogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeleteNetworkSegmentRangesLogic) DeleteNetworkSegmentRanges(in *opensta
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteNetworkSegmentRangesResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/network_segment_ranges/"+in.NetworkSegmentRangeId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	//token := common.GetToken()
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/network_segment_ranges/"+in.NetworkSegmentRangeId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletenodelogic.go

@@ -1,16 +1,13 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
+	"github.com/zeromicro/go-zero/core/logx"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type DeleteNodeLogic struct {
@@ -31,24 +28,31 @@ func (l *DeleteNodeLogic) DeleteNode(in *openstack.DeleteNodeReq) (*openstack.De
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteNodeResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackBareMetalUrl
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackBareMetalUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v1/nodes/"+in.NodeIdent, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackBareMetalUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackBareMetalUrl
+	//token := common.GetToken()
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v1/nodes/"+in.NodeIdent, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deleteportlogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeletePortLogic) DeletePort(in *openstack.DeletePortReq) (*openstack.De
 	// todo: add your logic here and delete this line
 	var resp openstack.DeletePortResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/ports/"+in.PortId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	//token := common.GetToken()
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/ports/"+in.PortId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deleterouterlogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeleteRouterLogic) DeleteRouter(in *openstack.DeleteRouterReq) (*openst
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteRouterResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/routers/"+in.RouterId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	//token := common.GetToken()
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl, bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/routers/"+in.RouterId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletesecuritygrouplogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeleteSecurityGroupLogic) DeleteSecurityGroup(in *openstack.DeleteSecur
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteSecurityGroupResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/security-groups/"+in.SecurityGroupId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	//token := common.GetToken()
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/v2.0/security-groups/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/security-groups/"+in.SecurityGroupId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletesecuritygrouprulelogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -32,23 +29,30 @@ func (l *DeleteSecurityGroupRuleLogic) DeleteSecurityGroupRule(in *openstack.Del
 	// todo: add your logic here and delete this line
 	var resp openstack.DeleteSecurityGroupRuleResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/security-groups/"+in.SecurityGroupRuleId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	//token := common.GetToken()
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/v2.0/security-groups/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/security-groups/"+in.SecurityGroupRuleId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deleteserverlogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
+	"github.com/zeromicro/go-zero/core/logx"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"strings"
-
-	"github.com/zeromicro/go-zero/core/logx"
 	"k8s.io/apimachinery/pkg/util/json"
 )
 
@@ -33,23 +30,30 @@ func (l *DeleteServerLogic) DeleteServer(in *openstack.DeleteServerReq) (*openst
 	var resp openstack.DeleteServerResp
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/servers/"+in.ServerId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackComputeUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/servers/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/servers/"+in.ServerId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletesubnetlogic.go

@@ -1,15 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -33,23 +30,30 @@ func (l *DeleteSubnetLogic) DeleteSubnet(in *openstack.DeleteSubnetReq) (*openst
 	var resp openstack.DeleteSubnetResp
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/subnets/"+in.SubnetId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 204 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 204 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/v2.0/subnets/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/subnets/"+in.SubnetId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 204 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 204 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletevolumelogic.go

@@ -1,16 +1,13 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
+	"github.com/zeromicro/go-zero/core/logx"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type DeleteVolumeLogic struct {
@@ -33,22 +30,29 @@ func (l *DeleteVolumeLogic) DeleteVolume(in *openstack.DeleteVolumeReq) (*openst
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackVolumev2Url
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/volumes/"+in.VolumeId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/volumes/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/v2.0/subnets/"+in.VolumeId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/deletevolumetypeslogic.go

@@ -1,16 +1,13 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
+	"github.com/zeromicro/go-zero/core/logx"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
-	"strings"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type DeleteVolumeTypesLogic struct {
@@ -33,22 +30,29 @@ func (l *DeleteVolumeTypesLogic) DeleteVolumeTypes(in *openstack.DeleteVolumeTyp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackVolumev2Url
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/types/"+in.VolumeTypeId, strings.NewReader(``), token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/types/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.DELETE, openstackUrl+"/types/"+in.VolumeTypeId, strings.NewReader(``), token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/getcomputelimitslogic.go

@@ -1,12 +1,10 @@
 package logic
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
 
@@ -32,22 +30,29 @@ func (l *GetComputeLimitsLogic) GetComputeLimits(in *openstack.GetComputeLimitsR
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackLimitsUrl
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackLimitsUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2/limits", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/types/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// token := common.GetToken()
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2/limits", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/getserversdetailedbyidlogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *GetServersDetailedByIdLogic) GetServersDetailedById(in *openstack.GetSe
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackComputeUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/servers/"+in.ServerId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/types/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/servers/"+in.ServerId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/getvolumedetailedbyidlogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *GetVolumeDetailedByIdLogic) GetVolumeDetailedById(in *openstack.GetVolu
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackVolumev2Url
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/volumes/"+in.VolumeId, nil, token)
+	//token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/volumes/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/volumes/"+in.VolumeId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/getvolumelimitslogic.go

@@ -1,12 +1,11 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"encoding/json"
-	"fmt"
-	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
+	"k8s.io/apimachinery/pkg/util/json"
 
+	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
 
@@ -32,22 +31,29 @@ func (l *GetVolumeLimitsLogic) GetVolumeLimits(in *openstack.GetVolumeLimitsReq)
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackVolumev2Url
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/limits", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("DELETE", openstackUrl+"/volumes/", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/limits", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listfirewallgroupslogic.go

@@ -1,14 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-	"k8s.io/apimachinery/pkg/util/json"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
+	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
@@ -33,23 +31,30 @@ func (l *ListFirewallGroupsLogic) ListFirewallGroups(in *openstack.ListFirewallG
 	var resp openstack.ListFirewallGroupsResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_groups", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/fwaas/firewall_groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	// token := common.GetToken()
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_groups", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listfirewallpolicieslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *ListFirewallPoliciesLogic) ListFirewallPolicies(in *openstack.ListFirew
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_policies", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/fwaas/firewall_groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_policies", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listfirewallruleslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -32,23 +31,30 @@ func (l *ListFirewallRulesLogic) ListFirewallRules(in *openstack.ListFirewallRul
 	var resp openstack.ListFirewallRulesResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_rules", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/fwaas/firewall_rules", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_rules", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listflavorsdetaillogic.go

@@ -1,12 +1,10 @@
 package logic
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
 
@@ -33,22 +31,29 @@ func (l *ListFlavorsDetailLogic) ListFlavorsDetail(in *openstack.ListFlavorsDeta
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackComputeUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/flavors/detail", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/flavors/detail", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/flavors/detail", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listfloatingipslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -32,24 +31,31 @@ func (l *ListFloatingIPsLogic) ListFloatingIPs(in *openstack.ListFloatingIPsReq)
 	// todo: add your logic here and delete this line
 	var resp openstack.ListFloatingIPsResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/floatingips", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/floatingips", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/floatingips", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listimageslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -31,24 +30,31 @@ func (l *ListImagesLogic) ListImages(in *openstack.ListImagesReq) (*openstack.Li
 	// todo: add your logic here and delete this line
 	var resp openstack.ListImagesResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackImageUrl
-	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackImageUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2/images", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackImageUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2/images", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackImageUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2/images", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listnetworksegmentrangeslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -31,23 +30,30 @@ func (l *ListNetworkSegmentRangesLogic) ListNetworkSegmentRanges(in *openstack.L
 	// todo: add your logic here and delete this line
 	var resp openstack.ListNetworkSegmentRangesResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/network_segment_ranges", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2/images", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/network_segment_ranges", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listnetworkslogic.go

@@ -1,12 +1,11 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
@@ -31,24 +30,31 @@ func (l *ListNetworksLogic) ListNetworks(in *openstack.ListNetworksReq) (*openst
 	var resp openstack.ListNetworksResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/networks", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
-
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/networks", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/networks", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+
+		return &resp, nil*/
 }

internal/logic/listnodeslogic.go

@@ -1,12 +1,11 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
@@ -32,23 +31,30 @@ func (l *ListNodesLogic) ListNodes(in *openstack.ListNodesReq) (*openstack.ListN
 	var resp openstack.ListNodesResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackBareMetalUrl
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackBareMetalUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v1/nodes/", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v1/nodes", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackBareMetalUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v1/nodes/", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listportslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -32,22 +31,29 @@ func (l *ListPortsLogic) ListPorts(in *openstack.ListPortsReq) (*openstack.ListP
 	var resp openstack.ListPortsResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/ports", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/ports", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/ports", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listrouterslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -32,22 +31,30 @@ func (l *ListRoutersLogic) ListRouters(in *openstack.ListRoutersReq) (*openstack
 	var resp openstack.ListRoutersResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/routers", nil, token)
+	//
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/routers", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/routers", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listsecuritygroupruleslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,23 +32,30 @@ func (l *ListSecurityGroupRulesLogic) ListSecurityGroupRules(in *openstack.ListS
 	var resp openstack.ListSecurityGroupRulesResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/security-group-rules", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/routers", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/security-group-rules", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 
 }

internal/logic/listsecuritygroupslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,23 +32,30 @@ func (l *ListSecurityGroupsLogic) ListSecurityGroups(in *openstack.ListSecurityG
 	var resp openstack.ListSecurityGroupsResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/security-groups", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/security-groups", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 
 }

internal/logic/listserversdetailedlogic.go

@@ -1,12 +1,11 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
@@ -31,23 +30,30 @@ func (l *ListServersDetailedLogic) ListServersDetailed(in *openstack.ListServers
 	var resp openstack.ListServersDetailedResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackComputeUrl
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/servers/detail", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/servers/detail", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listserverslogic.go

@@ -1,12 +1,11 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
@@ -31,22 +30,29 @@ func (l *ListServersLogic) ListServers(in *openstack.ListServersReq) (*openstack
 	var resp openstack.ListServersResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/servers", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/servers", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listsubnetslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -31,23 +30,30 @@ func (l *ListSubnetsLogic) ListSubnets(in *openstack.ListSubnetsReq) (*openstack
 	// todo: add your logic here and delete this line
 	var resp openstack.ListSubnetsResp
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
-	openstackUrl := platform.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/subnets", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	openstackUrl := platform.OpenstackNetworkUrl
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/subnets", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listvolumesdetaillogic.go

@@ -1,12 +1,10 @@
 package logic
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
 
@@ -33,22 +31,29 @@ func (l *ListVolumesDetailLogic) ListVolumesDetail(in *openstack.ListVolumesDeta
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackVolumev2Url
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/volumes/detail", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/volumes/detail", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listvolumeslogic.go

@@ -1,13 +1,11 @@
 package logic
 
 import (
+	"bytes"
+	"context"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-
-	"context"
-	"fmt"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
@@ -34,22 +32,29 @@ func (l *ListVolumesLogic) ListVolumes(in *openstack.ListVolumesReq) (*openstack
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackVolumev2Url
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/volumes", nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/volumes", nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/listvolumetypeslogic.go

@@ -1,12 +1,11 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"github.com/zeromicro/go-zero/core/logx"
@@ -32,24 +31,31 @@ func (l *ListVolumeTypesLogic) ListVolumeTypes(in *openstack.ListVolumeTypesReq)
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackVolumev2Url
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
-	token := common.GetToken()
-	//statusCode, body, err := tool.HttpClientWithScreen(tool.GET, openstackUrl+"/v3/"+in.ProjectId+"/types", strings.NewReader(``))
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/types", nil, token)
-
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		//statusCode, body, err := tool.HttpClientWithScreen(tool.GET, openstackUrl+"/v3/"+in.ProjectId+"/types", strings.NewReader(``))
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/types", nil, token)
+
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/migrateserverlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -41,23 +39,26 @@ func (l *MigrateServerLogic) MigrateServer(in *openstack.MigrateServerReq) (*ope
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/pauseserverlogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -40,23 +38,26 @@ func (l *PauseServerLogic) PauseServer(in *openstack.PauseServerReq) (*openstack
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/rebootserverlogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -38,22 +36,25 @@ func (l *RebootServerLogic) RebootServer(in *openstack.RebootServerReq) (*openst
 	}
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/rebuildserverlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -36,25 +34,28 @@ func (l *RebuildServerLogic) RebuildServer(in *openstack.RebuildServerReq) (*ope
 	if err != nil {
 		return nil, err
 	}
-	token := common.GetToken()
+	//token := common.GetToken()
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
 	openstackUrl := platform.OpenstackVolumev2Url
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/removesecuritygrouplogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -36,25 +34,28 @@ func (l *RemoveSecurityGroupLogic) RemoveSecurityGroup(in *openstack.RemoveSecur
 	if err != nil {
 		return nil, err
 	}
-	token := common.GetToken()
+	//token := common.GetToken()
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
 	openstackUrl := platform.OpenstackVolumev2Url
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/rescueserverlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -36,24 +34,27 @@ func (l *RescueServerLogic) RescueServer(in *openstack.RescueServerReq) (*openst
 	if err != nil {
 		return nil, err
 	}
-	token := common.GetToken()
+	//token := common.GetToken()
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackVolumev2Url
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/resizeserverlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -36,24 +34,27 @@ func (l *ResizeServerLogic) ResizeServer(in *openstack.ResizeServerReq) (*openst
 	if err != nil {
 		return nil, err
 	}
-	token := common.GetToken()
+	//token := common.GetToken()
 	payload := strings.NewReader(string(reqByte))
 	openstackUrl := platform.OpenstackVolumev2Url
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/shelveserverlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -41,23 +39,26 @@ func (l *ShelveServerLogic) ShelveServer(in *openstack.ShelveServerReq) (*openst
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	//token := common.GetToken()
+	/*	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/showfirewallgroupdetailslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *ShowFirewallGroupDetailsLogic) ShowFirewallGroupDetails(in *openstack.S
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_groups/"+in.FirewallGroupId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_groups/"+in.FirewallGroupId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/showfirewallpolicydetailslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *ShowFirewallPolicyDetailsLogic) ShowFirewallPolicyDetails(in *openstack
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_policies/"+in.FirewallPolicyId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_policies/"+in.FirewallPolicyId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/showfirewallruledetailslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *ShowFirewallRuleDetailsLogic) ShowFirewallRuleDetails(in *openstack.Sho
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_rules/"+in.FirewallRuleId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/fwaas/firewall_rules/"+in.FirewallRuleId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/showfloatingipdetailslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *ShowFloatingIPDetailsLogic) ShowFloatingIPDetails(in *openstack.ShowFlo
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/floatingips/"+in.FloatingipId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/floatingips/"+in.FloatingipId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/shownetworkdetailslogic.go

@@ -1,13 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"github.com/zeromicro/go-zero/core/logx"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 )
 
@@ -32,22 +31,29 @@ func (l *ShowNetworkDetailsLogic) ShowNetworkDetails(in *openstack.ShowNetworkDe
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/networks/"+in.NetworkId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/networks/"+in.NetworkId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/shownetworksegmentrangedetailslogic.go

@@ -1,13 +1,11 @@
 package logic
 
 import (
+	"bytes"
 	"context"
 	"k8s.io/apimachinery/pkg/util/json"
 
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
-
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
 
@@ -34,22 +32,29 @@ func (l *ShowNetworkSegmentRangeDetailsLogic) ShowNetworkSegmentRangeDetails(in
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/network_segment_ranges/"+in.NetworkSegmentRangeId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/network_segment_ranges/"+in.NetworkSegmentRangeId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/shownodedetailslogic.go

@@ -1,13 +1,12 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"github.com/zeromicro/go-zero/core/logx"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 )
 
@@ -31,22 +30,29 @@ func (l *ShowNodeDetailsLogic) ShowNodeDetails(in *openstack.ShowNodeDetailsReq)
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackBareMetalUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackBareMetalUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v1/nodes/"+in.NodeIdent, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v1/nodes/"+in.NodeIdent, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/showportdetailslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *ShowPortDetailsLogic) ShowPortDetails(in *openstack.ShowPortDetailsReq)
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/ports/"+in.PortId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/ports/"+in.PortId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/showrouterdetailslogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *ShowRouterDetailsLogic) ShowRouterDetails(in *openstack.ShowRouterDetai
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/routers"+in.RouterId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/routers"+in.RouterId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/showsecuritygrouplogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *ShowSecurityGroupLogic) ShowSecurityGroup(in *openstack.ShowSecurityGro
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/security-groups/"+in.SecurityGroupId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/security-groups/"+in.SecurityGroupId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/showsecuritygrouprulelogic.go

@@ -1,10 +1,9 @@
 package logic
 
 import (
+	"bytes"
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
@@ -33,22 +32,29 @@ func (l *ShowSecurityGroupRuleLogic) ShowSecurityGroupRule(in *openstack.ShowSec
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackNetworkUrl
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/security-group-rules/"+in.SecurityGroupRuleId, nil, token)
 	if err != nil {
 		return nil, err
 	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	reqByte, err := json.Marshal(in)
+	body, err := common.SendRequest("GET", openstackUrl+"/v2.0/security-groups", bytes.NewBuffer(reqByte), in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.GET, openstackUrl+"/v2.0/security-group-rules/"+in.SecurityGroupRuleId, nil, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/startserverlogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -41,22 +39,25 @@ func (l *StartServerLogic) StartServer(in *openstack.StartServerReq) (*openstack
 	}
 	payload := strings.NewReader(string(reqByte))
 	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/stopserverlogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -40,23 +38,26 @@ func (l *StopServerLogic) StopServer(in *openstack.StopServerReq) (*openstack.St
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/suspendserverlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -41,23 +39,26 @@ func (l *SuspendServerLogic) SuspendServer(in *openstack.SuspendServerReq) (*ope
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/unpauseserverlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -41,23 +39,26 @@ func (l *UnpauseServerLogic) UnpauseServer(in *openstack.UnpauseServerReq) (*ope
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/unrescuelogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -41,23 +39,26 @@ func (l *UnRescueLogic) UnRescue(in *openstack.UnRescueServerReq) (*openstack.Un
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	//openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/unshelveserverlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -41,22 +39,25 @@ func (l *UnshelveServerLogic) UnshelveServer(in *openstack.UnshelveServerReq) (*
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers/"+in.ServerId+"/action", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updatefirewallgrouplogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -39,22 +37,25 @@ func (l *UpdateFirewallGroupLogic) UpdateFirewallGroup(in *openstack.UpdateFirew
 	}
 	payload := strings.NewReader(string(reqByte))
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/fwaas/firewall_groups/"+in.FirewallGroupId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/fwaas/firewall_groups/"+in.FirewallGroupId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updatefloatingiplogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -39,22 +37,25 @@ func (l *UpdateFloatingIPLogic) UpdateFloatingIP(in *openstack.UpdateFloatingIPR
 	}
 	payload := strings.NewReader(string(reqByte))
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/floatingips/"+in.FloatingipId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/floatingips/"+in.FloatingipId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updatenetworklogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -38,22 +36,26 @@ func (l *UpdateNetworkLogic) UpdateNetwork(in *openstack.UpdateNetworkReq) (*ope
 	}
 	payload := strings.NewReader(string(reqByte))
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/networks/"+in.NetworkId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/networks/"+in.NetworkId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updatenetworksegmentrangeslogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -38,23 +36,26 @@ func (l *UpdateNetworkSegmentRangesLogic) UpdateNetworkSegmentRanges(in *opensta
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/network_segment_ranges/"+in.NetworkSegmentRangeId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("POST", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/network_segment_ranges/"+in.NetworkSegmentRangeId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updateportlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -38,23 +36,26 @@ func (l *UpdatePortLogic) UpdatePort(in *openstack.UpdatePortReq) (*openstack.Up
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/ports/"+in.PortId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("PUT", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/ports/"+in.PortId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updaterouterlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -38,23 +36,26 @@ func (l *UpdateRouterLogic) UpdateRouter(in *openstack.UpdateRouterReq) (*openst
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/routers/"+in.RouterId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("PUT", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/routers/"+in.RouterId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updatesecuritygrouplogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -38,23 +36,26 @@ func (l *UpdateSecurityGroupLogic) UpdateSecurityGroup(in *openstack.UpdateSecur
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/security-groups/"+in.SecurityGroupId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("PUT", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackNetworkUrl
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/security-groups/"+in.SecurityGroupId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updateserverlogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -39,22 +37,25 @@ func (l *UpdateServerLogic) UpdateServer(in *openstack.UpdateServerReq) (*openst
 	}
 	payload := strings.NewReader(string(reqByte))
 	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/servers/"+in.ServerId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("PUT", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/servers/"+in.ServerId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updatesubnetlogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -38,22 +36,26 @@ func (l *UpdateSubnetLogic) UpdateSubnet(in *openstack.UpdateSubnetReq) (*openst
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/subnets/"+in.SubnetId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+
+	body, err := common.SendRequest("PUT", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/v2.0/subnets/"+in.SubnetId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/updatevolumelogic.go

@@ -2,11 +2,9 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/svc"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/openstack"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -37,23 +35,26 @@ func (l *UpdateVolumeLogic) UpdateVolume(in *openstack.UpdateVolumeReq) (*openst
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
-	token := common.GetToken()
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/types"+in.VolumeId, payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 200 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 200 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("PUT", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackVolumev2Url
+	/*	token := common.GetToken()
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.PUT, openstackUrl+"/types"+in.VolumeId, payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 200 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 200 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }

internal/logic/uploadimagelogic.go

@@ -2,9 +2,7 @@ package logic
 
 import (
 	"context"
-	"fmt"
 	"gitlink.org.cn/jcce-pcm/pcm-participant-openstack/internal/common"
-	"gitlink.org.cn/jcce-pcm/utils/tool"
 	"k8s.io/apimachinery/pkg/util/json"
 	"strings"
 
@@ -34,27 +32,34 @@ func (l *UploadImageLogic) UploadImage(in *openstack.UploadOsImageReq) (*opensta
 	platform, err := common.GetOpenstackConfWithPlatform(in.Platform)
 	openstackUrl := platform.OpenstackComputeUrl
 	reqByte, err := json.Marshal(in)
-	token := common.GetToken()
 	if err != nil {
 		return nil, err
 	}
 	payload := strings.NewReader(string(reqByte))
-	// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
-	statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers", payload, token)
-	if err != nil {
-		return nil, err
-	}
-	if statusCode == 202 {
-		err := json.Unmarshal(body, &resp)
-		if err != nil {
-			fmt.Println(err)
-		}
-		resp.Code = 200
-		resp.Msg = "Success"
-	} else if statusCode != 202 {
-		json.Unmarshal(body, &resp)
-		resp.Code = 400
-		resp.Msg = "Failure"
-	}
+	body, err := common.SendRequest("PUT", openstackUrl, payload, in.Platform)
+	json.Unmarshal(*body, &resp)
 	return &resp, nil
+	/*	token := common.GetToken()
+		if err != nil {
+			return nil, err
+		}
+		payload := strings.NewReader(string(reqByte))
+		// openstackUrl := l.svcCtx.Config.OpenstackConfig.OpenstackComputeUrl
+		statusCode, body, err := tool.HttpClientWithBodyAndCode(tool.POST, openstackUrl+"/servers", payload, token)
+		if err != nil {
+			return nil, err
+		}
+		if statusCode == 202 {
+			err := json.Unmarshal(body, &resp)
+			if err != nil {
+				fmt.Println(err)
+			}
+			resp.Code = 200
+			resp.Msg = "Success"
+		} else if statusCode != 202 {
+			json.Unmarshal(body, &resp)
+			resp.Code = 400
+			resp.Msg = "Failure"
+		}
+		return &resp, nil*/
 }