598 lines
18 KiB
Go
598 lines
18 KiB
Go
/*
|
|
Copyright 2020 KubeSphere Authors
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package fake
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
|
|
"github.com/emicklei/go-restful/v3"
|
|
v1 "k8s.io/api/core/v1"
|
|
|
|
devopsv1alpha3 "kubesphere.io/api/devops/v1alpha3"
|
|
|
|
"kubesphere.io/kubesphere/pkg/simple/client/devops"
|
|
)
|
|
|
|
type Devops struct {
|
|
Data map[string]interface{}
|
|
|
|
Projects map[string]interface{}
|
|
|
|
Pipelines map[string]map[string]*devopsv1alpha3.Pipeline
|
|
|
|
Credentials map[string]map[string]*v1.Secret
|
|
}
|
|
|
|
func New(projects ...string) *Devops {
|
|
d := &Devops{
|
|
Data: nil,
|
|
Projects: map[string]interface{}{},
|
|
Pipelines: map[string]map[string]*devopsv1alpha3.Pipeline{},
|
|
Credentials: map[string]map[string]*v1.Secret{},
|
|
}
|
|
for _, p := range projects {
|
|
d.Projects[p] = true
|
|
}
|
|
return d
|
|
}
|
|
func NewWithPipelines(project string, pipelines ...*devopsv1alpha3.Pipeline) *Devops {
|
|
d := &Devops{
|
|
Data: nil,
|
|
Projects: map[string]interface{}{},
|
|
Pipelines: map[string]map[string]*devopsv1alpha3.Pipeline{},
|
|
Credentials: map[string]map[string]*v1.Secret{},
|
|
}
|
|
|
|
d.Projects[project] = true
|
|
d.Pipelines[project] = map[string]*devopsv1alpha3.Pipeline{}
|
|
for _, f := range pipelines {
|
|
d.Pipelines[project][f.Name] = f
|
|
}
|
|
return d
|
|
}
|
|
|
|
func NewWithCredentials(project string, credentials ...*v1.Secret) *Devops {
|
|
d := &Devops{
|
|
Data: nil,
|
|
Projects: map[string]interface{}{},
|
|
Credentials: map[string]map[string]*v1.Secret{},
|
|
}
|
|
|
|
d.Projects[project] = true
|
|
d.Credentials[project] = map[string]*v1.Secret{}
|
|
for _, f := range credentials {
|
|
d.Credentials[project][f.Name] = f
|
|
}
|
|
return d
|
|
}
|
|
|
|
func (d *Devops) CreateDevOpsProject(projectId string) (string, error) {
|
|
if _, ok := d.Projects[projectId]; ok {
|
|
return projectId, nil
|
|
}
|
|
d.Projects[projectId] = true
|
|
d.Pipelines[projectId] = map[string]*devopsv1alpha3.Pipeline{}
|
|
d.Credentials[projectId] = map[string]*v1.Secret{}
|
|
return projectId, nil
|
|
}
|
|
|
|
func (d *Devops) DeleteDevOpsProject(projectId string) error {
|
|
if _, ok := d.Projects[projectId]; ok {
|
|
delete(d.Projects, projectId)
|
|
delete(d.Pipelines, projectId)
|
|
delete(d.Credentials, projectId)
|
|
return nil
|
|
} else {
|
|
return &devops.ErrorResponse{
|
|
Body: []byte{},
|
|
Response: &http.Response{
|
|
Status: "404 Not Found",
|
|
StatusCode: 404,
|
|
Proto: "HTTP/1.1",
|
|
ProtoMajor: 1,
|
|
ProtoMinor: 1,
|
|
ContentLength: 50,
|
|
Header: http.Header{
|
|
"Foo": []string{"Bar"},
|
|
},
|
|
Body: io.NopCloser(strings.NewReader("foo")), // shouldn't be used
|
|
},
|
|
Message: "",
|
|
}
|
|
}
|
|
}
|
|
|
|
func (d *Devops) GetDevOpsProject(projectId string) (string, error) {
|
|
if _, ok := d.Projects[projectId]; ok {
|
|
return projectId, nil
|
|
} else {
|
|
return "", &devops.ErrorResponse{
|
|
Body: []byte{},
|
|
Response: &http.Response{
|
|
Status: "404 Not Found",
|
|
StatusCode: 404,
|
|
Proto: "HTTP/1.1",
|
|
ProtoMajor: 1,
|
|
ProtoMinor: 1,
|
|
ContentLength: 50,
|
|
Header: http.Header{
|
|
"Foo": []string{"Bar"},
|
|
},
|
|
Body: io.NopCloser(strings.NewReader("foo")), // shouldn't be used
|
|
Request: &http.Request{
|
|
Method: "",
|
|
URL: &url.URL{
|
|
Scheme: "",
|
|
Opaque: "",
|
|
User: nil,
|
|
Host: "",
|
|
Path: "",
|
|
RawPath: "",
|
|
ForceQuery: false,
|
|
RawQuery: "",
|
|
Fragment: "",
|
|
},
|
|
},
|
|
},
|
|
Message: "",
|
|
}
|
|
}
|
|
}
|
|
|
|
func NewFakeDevops(data map[string]interface{}) *Devops {
|
|
var fakeData Devops
|
|
fakeData.Data = data
|
|
return &fakeData
|
|
}
|
|
|
|
// Pipelinne operator interface
|
|
func (d *Devops) GetPipeline(projectName, pipelineName string, httpParameters *devops.HttpParameters) (*devops.Pipeline, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (d *Devops) ListPipelines(httpParameters *devops.HttpParameters) (*devops.PipelineList, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetPipelineRun(projectName, pipelineName, runId string, httpParameters *devops.HttpParameters) (*devops.PipelineRun, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) ListPipelineRuns(projectName, pipelineName string, httpParameters *devops.HttpParameters) (*devops.PipelineRunList, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) StopPipeline(projectName, pipelineName, runId string, httpParameters *devops.HttpParameters) (*devops.StopPipeline, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) ReplayPipeline(projectName, pipelineName, runId string, httpParameters *devops.HttpParameters) (*devops.ReplayPipeline, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) RunPipeline(projectName, pipelineName string, httpParameters *devops.HttpParameters) (*devops.RunPipeline, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetArtifacts(projectName, pipelineName, runId string, httpParameters *devops.HttpParameters) ([]devops.Artifacts, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetRunLog(projectName, pipelineName, runId string, httpParameters *devops.HttpParameters) ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetStepLog(projectName, pipelineName, runId, nodeId, stepId string, httpParameters *devops.HttpParameters) ([]byte, http.Header, error) {
|
|
return nil, nil, nil
|
|
}
|
|
func (d *Devops) GetNodeSteps(projectName, pipelineName, runId, nodeId string, httpParameters *devops.HttpParameters) ([]devops.NodeSteps, error) {
|
|
s := []string{projectName, pipelineName, runId, nodeId}
|
|
key := strings.Join(s, "-")
|
|
res := d.Data[key].([]devops.NodeSteps)
|
|
return res, nil
|
|
}
|
|
func (d *Devops) GetPipelineRunNodes(projectName, pipelineName, runId string, httpParameters *devops.HttpParameters) ([]devops.PipelineRunNodes, error) {
|
|
s := []string{projectName, pipelineName, runId}
|
|
key := strings.Join(s, "-")
|
|
res := d.Data[key].([]devops.PipelineRunNodes)
|
|
return res, nil
|
|
}
|
|
func (d *Devops) SubmitInputStep(projectName, pipelineName, runId, nodeId, stepId string, httpParameters *devops.HttpParameters) ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
// BranchPipelinne operator interface
|
|
func (d *Devops) GetBranchPipeline(projectName, pipelineName, branchName string, httpParameters *devops.HttpParameters) (*devops.BranchPipeline, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetBranchPipelineRun(projectName, pipelineName, branchName, runId string, httpParameters *devops.HttpParameters) (*devops.PipelineRun, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) StopBranchPipeline(projectName, pipelineName, branchName, runId string, httpParameters *devops.HttpParameters) (*devops.StopPipeline, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) ReplayBranchPipeline(projectName, pipelineName, branchName, runId string, httpParameters *devops.HttpParameters) (*devops.ReplayPipeline, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) RunBranchPipeline(projectName, pipelineName, branchName string, httpParameters *devops.HttpParameters) (*devops.RunPipeline, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetBranchArtifacts(projectName, pipelineName, branchName, runId string, httpParameters *devops.HttpParameters) ([]devops.Artifacts, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetBranchRunLog(projectName, pipelineName, branchName, runId string, httpParameters *devops.HttpParameters) ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetBranchStepLog(projectName, pipelineName, branchName, runId, nodeId, stepId string, httpParameters *devops.HttpParameters) ([]byte, http.Header, error) {
|
|
return nil, nil, nil
|
|
}
|
|
func (d *Devops) GetBranchNodeSteps(projectName, pipelineName, branchName, runId, nodeId string, httpParameters *devops.HttpParameters) ([]devops.NodeSteps, error) {
|
|
s := []string{projectName, pipelineName, branchName, runId, nodeId}
|
|
key := strings.Join(s, "-")
|
|
res := d.Data[key].([]devops.NodeSteps)
|
|
return res, nil
|
|
}
|
|
func (d *Devops) GetBranchPipelineRunNodes(projectName, pipelineName, branchName, runId string, httpParameters *devops.HttpParameters) ([]devops.BranchPipelineRunNodes, error) {
|
|
s := []string{projectName, pipelineName, branchName, runId}
|
|
key := strings.Join(s, "-")
|
|
res := d.Data[key].([]devops.BranchPipelineRunNodes)
|
|
return res, nil
|
|
}
|
|
func (d *Devops) SubmitBranchInputStep(projectName, pipelineName, branchName, runId, nodeId, stepId string, httpParameters *devops.HttpParameters) ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetPipelineBranch(projectName, pipelineName string, httpParameters *devops.HttpParameters) (*devops.PipelineBranch, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) ScanBranch(projectName, pipelineName string, httpParameters *devops.HttpParameters) ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
// Common pipeline operator interface
|
|
func (d *Devops) GetConsoleLog(projectName, pipelineName string, httpParameters *devops.HttpParameters) ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetCrumb(httpParameters *devops.HttpParameters) (*devops.Crumb, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
// SCM operator interface
|
|
func (d *Devops) GetSCMServers(scmId string, httpParameters *devops.HttpParameters) ([]devops.SCMServer, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetSCMOrg(scmId string, httpParameters *devops.HttpParameters) ([]devops.SCMOrg, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetOrgRepo(scmId, organizationId string, httpParameters *devops.HttpParameters) (devops.OrgRepo, error) {
|
|
return devops.OrgRepo{}, nil
|
|
}
|
|
func (d *Devops) CreateSCMServers(scmId string, httpParameters *devops.HttpParameters) (*devops.SCMServer, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) Validate(scmId string, httpParameters *devops.HttpParameters) (*devops.Validates, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
// Webhook operator interface
|
|
func (d *Devops) GetNotifyCommit(httpParameters *devops.HttpParameters) ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GithubWebhook(httpParameters *devops.HttpParameters) ([]byte, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (d *Devops) CheckScriptCompile(projectName, pipelineName string, httpParameters *devops.HttpParameters) (*devops.CheckScript, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) CheckCron(projectName string, httpParameters *devops.HttpParameters) (*devops.CheckCronRes, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) ToJenkinsfile(httpParameters *devops.HttpParameters) (*devops.ResJenkinsfile, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) ToJson(httpParameters *devops.HttpParameters) (map[string]interface{}, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
// CredentialOperator
|
|
func (d *Devops) CreateCredentialInProject(projectId string, credential *v1.Secret) (string, error) {
|
|
if _, ok := d.Credentials[projectId][credential.Name]; ok {
|
|
err := fmt.Errorf("credential name [%s] has been used", credential.Name)
|
|
return "", restful.NewError(http.StatusConflict, err.Error())
|
|
}
|
|
d.Credentials[projectId][credential.Name] = credential
|
|
return credential.Name, nil
|
|
}
|
|
func (d *Devops) UpdateCredentialInProject(projectId string, credential *v1.Secret) (string, error) {
|
|
if _, ok := d.Credentials[projectId][credential.Name]; !ok {
|
|
err := &devops.ErrorResponse{
|
|
Body: []byte{},
|
|
Response: &http.Response{
|
|
Status: "404 Not Found",
|
|
StatusCode: 404,
|
|
Proto: "HTTP/1.1",
|
|
ProtoMajor: 1,
|
|
ProtoMinor: 1,
|
|
ContentLength: 50,
|
|
Header: http.Header{
|
|
"Foo": []string{"Bar"},
|
|
},
|
|
Body: io.NopCloser(strings.NewReader("foo")), // shouldn't be used
|
|
Request: &http.Request{
|
|
Method: "",
|
|
URL: &url.URL{
|
|
Scheme: "",
|
|
Opaque: "",
|
|
User: nil,
|
|
Host: "",
|
|
Path: "",
|
|
RawPath: "",
|
|
ForceQuery: false,
|
|
RawQuery: "",
|
|
Fragment: "",
|
|
},
|
|
},
|
|
},
|
|
Message: "",
|
|
}
|
|
return "", err
|
|
}
|
|
d.Credentials[projectId][credential.Name] = credential
|
|
return credential.Name, nil
|
|
}
|
|
|
|
func (d *Devops) GetCredentialInProject(projectId, id string) (*devops.Credential, error) {
|
|
if _, ok := d.Credentials[projectId][id]; !ok {
|
|
err := &devops.ErrorResponse{
|
|
Body: []byte{},
|
|
Response: &http.Response{
|
|
Status: "404 Not Found",
|
|
StatusCode: 404,
|
|
Proto: "HTTP/1.1",
|
|
ProtoMajor: 1,
|
|
ProtoMinor: 1,
|
|
ContentLength: 50,
|
|
Header: http.Header{
|
|
"Foo": []string{"Bar"},
|
|
},
|
|
Body: io.NopCloser(strings.NewReader("foo")), // shouldn't be used
|
|
Request: &http.Request{
|
|
Method: "",
|
|
URL: &url.URL{
|
|
Scheme: "",
|
|
Opaque: "",
|
|
User: nil,
|
|
Host: "",
|
|
Path: "",
|
|
RawPath: "",
|
|
ForceQuery: false,
|
|
RawQuery: "",
|
|
Fragment: "",
|
|
},
|
|
},
|
|
},
|
|
Message: "",
|
|
}
|
|
return nil, err
|
|
}
|
|
return &devops.Credential{Id: id}, nil
|
|
}
|
|
func (d *Devops) GetCredentialsInProject(projectId string) ([]*devops.Credential, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) DeleteCredentialInProject(projectId, id string) (string, error) {
|
|
if _, ok := d.Credentials[projectId][id]; !ok {
|
|
err := &devops.ErrorResponse{
|
|
Body: []byte{},
|
|
Response: &http.Response{
|
|
Status: "404 Not Found",
|
|
StatusCode: 404,
|
|
Proto: "HTTP/1.1",
|
|
ProtoMajor: 1,
|
|
ProtoMinor: 1,
|
|
ContentLength: 50,
|
|
Header: http.Header{
|
|
"Foo": []string{"Bar"},
|
|
},
|
|
Body: io.NopCloser(strings.NewReader("foo")), // shouldn't be used
|
|
Request: &http.Request{
|
|
Method: "",
|
|
URL: &url.URL{
|
|
Scheme: "",
|
|
Opaque: "",
|
|
User: nil,
|
|
Host: "",
|
|
Path: "",
|
|
RawPath: "",
|
|
ForceQuery: false,
|
|
RawQuery: "",
|
|
Fragment: "",
|
|
},
|
|
},
|
|
},
|
|
Message: "",
|
|
}
|
|
return "", err
|
|
}
|
|
delete(d.Credentials[projectId], id)
|
|
return "", nil
|
|
}
|
|
|
|
// BuildGetter
|
|
func (d *Devops) GetProjectPipelineBuildByType(projectId, pipelineId string, status string) (*devops.Build, error) {
|
|
return nil, nil
|
|
}
|
|
func (d *Devops) GetMultiBranchPipelineBuildByType(projectId, pipelineId, branch string, status string) (*devops.Build, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
// ProjectPipelineOperator
|
|
func (d *Devops) CreateProjectPipeline(projectId string, pipeline *devopsv1alpha3.Pipeline) (string, error) {
|
|
if _, ok := d.Pipelines[projectId][pipeline.Name]; ok {
|
|
err := fmt.Errorf("pipeline name [%s] has been used", pipeline.Name)
|
|
return "", restful.NewError(http.StatusConflict, err.Error())
|
|
}
|
|
d.Pipelines[projectId][pipeline.Name] = pipeline
|
|
return "", nil
|
|
}
|
|
|
|
func (d *Devops) DeleteProjectPipeline(projectId string, pipelineId string) (string, error) {
|
|
if _, ok := d.Pipelines[projectId][pipelineId]; !ok {
|
|
err := &devops.ErrorResponse{
|
|
Body: []byte{},
|
|
Response: &http.Response{
|
|
Status: "404 Not Found",
|
|
StatusCode: 404,
|
|
Proto: "HTTP/1.1",
|
|
ProtoMajor: 1,
|
|
ProtoMinor: 1,
|
|
ContentLength: 50,
|
|
Header: http.Header{
|
|
"Foo": []string{"Bar"},
|
|
},
|
|
Body: io.NopCloser(strings.NewReader("foo")), // shouldn't be used
|
|
Request: &http.Request{
|
|
Method: "",
|
|
URL: &url.URL{
|
|
Scheme: "",
|
|
Opaque: "",
|
|
User: nil,
|
|
Host: "",
|
|
Path: "",
|
|
RawPath: "",
|
|
ForceQuery: false,
|
|
RawQuery: "",
|
|
Fragment: "",
|
|
},
|
|
},
|
|
},
|
|
Message: "",
|
|
}
|
|
return "", err
|
|
}
|
|
delete(d.Pipelines[projectId], pipelineId)
|
|
return "", nil
|
|
}
|
|
|
|
func (d *Devops) UpdateProjectPipeline(projectId string, pipeline *devopsv1alpha3.Pipeline) (string, error) {
|
|
if _, ok := d.Pipelines[projectId][pipeline.Name]; !ok {
|
|
err := &devops.ErrorResponse{
|
|
Body: []byte{},
|
|
Response: &http.Response{
|
|
Status: "404 Not Found",
|
|
StatusCode: 404,
|
|
Proto: "HTTP/1.1",
|
|
ProtoMajor: 1,
|
|
ProtoMinor: 1,
|
|
ContentLength: 50,
|
|
Header: http.Header{
|
|
"Foo": []string{"Bar"},
|
|
},
|
|
Body: io.NopCloser(strings.NewReader("foo")), // shouldn't be used
|
|
Request: &http.Request{
|
|
Method: "",
|
|
URL: &url.URL{
|
|
Scheme: "",
|
|
Opaque: "",
|
|
User: nil,
|
|
Host: "",
|
|
Path: "",
|
|
RawPath: "",
|
|
ForceQuery: false,
|
|
RawQuery: "",
|
|
Fragment: "",
|
|
},
|
|
},
|
|
},
|
|
Message: "",
|
|
}
|
|
return "", err
|
|
}
|
|
d.Pipelines[projectId][pipeline.Name] = pipeline
|
|
return "", nil
|
|
}
|
|
|
|
func (d *Devops) GetProjectPipelineConfig(projectId, pipelineId string) (*devopsv1alpha3.Pipeline, error) {
|
|
if _, ok := d.Pipelines[projectId][pipelineId]; !ok {
|
|
err := &devops.ErrorResponse{
|
|
Body: []byte{},
|
|
Response: &http.Response{
|
|
Status: "404 Not Found",
|
|
StatusCode: 404,
|
|
Proto: "HTTP/1.1",
|
|
ProtoMajor: 1,
|
|
ProtoMinor: 1,
|
|
ContentLength: 50,
|
|
Header: http.Header{
|
|
"Foo": []string{"Bar"},
|
|
},
|
|
Body: io.NopCloser(strings.NewReader("foo")), // shouldn't be used
|
|
Request: &http.Request{
|
|
Method: "",
|
|
URL: &url.URL{
|
|
Scheme: "",
|
|
Opaque: "",
|
|
User: nil,
|
|
Host: "",
|
|
Path: "",
|
|
RawPath: "",
|
|
ForceQuery: false,
|
|
RawQuery: "",
|
|
Fragment: "",
|
|
},
|
|
},
|
|
},
|
|
Message: "",
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return d.Pipelines[projectId][pipelineId], nil
|
|
}
|
|
|
|
func (d *Devops) AddGlobalRole(roleName string, ids devops.GlobalPermissionIds, overwrite bool) error {
|
|
return nil
|
|
}
|
|
|
|
func (d *Devops) AddProjectRole(roleName string, pattern string, ids devops.ProjectPermissionIds, overwrite bool) error {
|
|
return nil
|
|
}
|
|
|
|
func (d *Devops) DeleteProjectRoles(roleName ...string) error {
|
|
return nil
|
|
}
|
|
|
|
func (d *Devops) AssignProjectRole(roleName string, sid string) error {
|
|
return nil
|
|
}
|
|
|
|
func (d *Devops) UnAssignProjectRole(roleName string, sid string) error {
|
|
return nil
|
|
}
|
|
|
|
func (d *Devops) AssignGlobalRole(roleName string, sid string) error {
|
|
return nil
|
|
}
|
|
|
|
func (d *Devops) UnAssignGlobalRole(roleName string, sid string) error {
|
|
return nil
|
|
}
|
|
|
|
func (d *Devops) DeleteUserInProject(sid string) error {
|
|
return nil
|
|
}
|
|
|
|
func (d *Devops) GetGlobalRole(roleName string) (string, error) {
|
|
return "", nil
|
|
}
|