diff --git a/pkg/simple/client/devops/jenkins/internal/bitbucket.go b/pkg/simple/client/devops/jenkins/internal/bitbucket.go new file mode 100644 index 0000000000000000000000000000000000000000..6a0378d411d7a115e44e8dce6dc56b367b5dc14f --- /dev/null +++ b/pkg/simple/client/devops/jenkins/internal/bitbucket.go @@ -0,0 +1,146 @@ +package internal + +import ( + "github.com/beevik/etree" + "k8s.io/klog" + "strconv" + "strings" + + devopsv1alpha3 "kubesphere.io/kubesphere/pkg/apis/devops/v1alpha3" +) + +func AppendBitbucketServerSourceToEtree(source *etree.Element, gitSource *devopsv1alpha3.BitbucketServerSource) { + if gitSource == nil { + klog.Warning("please provide BitbucketServer source when the sourceType is BitbucketServer") + return + } + source.CreateAttr("class", "com.cloudbees.jenkins.plugins.bitbucket.BitbucketSCMSource") + source.CreateAttr("plugin", "cloudbees-bitbucket-branch-source") + source.CreateElement("id").SetText(gitSource.ScmId) + source.CreateElement("credentialsId").SetText(gitSource.CredentialId) + source.CreateElement("repoOwner").SetText(gitSource.Owner) + source.CreateElement("repository").SetText(gitSource.Repo) + source.CreateElement("serverUrl").SetText(gitSource.ApiUri) + + traits := source.CreateElement("traits") + if gitSource.DiscoverBranches != 0 { + traits.CreateElement("com.cloudbees.jenkins.plugins.bitbucket.BranchDiscoveryTrait>"). + CreateElement("strategyId").SetText(strconv.Itoa(gitSource.DiscoverBranches)) + } + if gitSource.DiscoverPRFromOrigin != 0 { + traits.CreateElement("com.cloudbees.jenkins.plugins.bitbucket.OriginPullRequestDiscoveryTrait"). + CreateElement("strategyId").SetText(strconv.Itoa(gitSource.DiscoverPRFromOrigin)) + } + if gitSource.DiscoverPRFromForks != nil { + forkTrait := traits.CreateElement("com.cloudbees.jenkins.plugins.bitbucket.ForkPullRequestDiscoveryTrait") + forkTrait.CreateElement("strategyId").SetText(strconv.Itoa(gitSource.DiscoverPRFromForks.Strategy)) + trustClass := "com.cloudbees.jenkins.plugins.bitbucket.ForkPullRequestDiscoveryTrait$" + + if prTrust := PRDiscoverTrust(gitSource.DiscoverPRFromForks.Trust); prTrust.IsValid() { + trustClass += prTrust.String() + } else { + klog.Warningf("invalid Bitbucket discover PR trust value: %d", prTrust.Value()) + } + + forkTrait.CreateElement("trust").CreateAttr("class", trustClass) + } + if gitSource.DiscoverTags { + traits.CreateElement("com.cloudbees.jenkins.plugins.bitbucket.TagDiscoveryTrait") + } + if gitSource.CloneOption != nil { + cloneExtension := traits.CreateElement("jenkins.plugins.git.traits.CloneOptionTrait").CreateElement("extension") + cloneExtension.CreateAttr("class", "hudson.plugins.git.extensions.impl.CloneOption") + cloneExtension.CreateElement("shallow").SetText(strconv.FormatBool(gitSource.CloneOption.Shallow)) + cloneExtension.CreateElement("noTags").SetText(strconv.FormatBool(false)) + cloneExtension.CreateElement("honorRefspec").SetText(strconv.FormatBool(true)) + cloneExtension.CreateElement("reference") + if gitSource.CloneOption.Timeout >= 0 { + cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(gitSource.CloneOption.Timeout)) + } else { + cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(10)) + } + + if gitSource.CloneOption.Depth >= 0 { + cloneExtension.CreateElement("depth").SetText(strconv.Itoa(gitSource.CloneOption.Depth)) + } else { + cloneExtension.CreateElement("depth").SetText(strconv.Itoa(1)) + } + } + if gitSource.RegexFilter != "" { + regexTraits := traits.CreateElement("jenkins.scm.impl.trait.RegexSCMHeadFilterTrait") + regexTraits.CreateAttr("plugin", "scm-api") + regexTraits.CreateElement("regex").SetText(gitSource.RegexFilter) + } + return +} + +func GetBitbucketServerSourceFromEtree(source *etree.Element) *devopsv1alpha3.BitbucketServerSource { + var s devopsv1alpha3.BitbucketServerSource + if credential := source.SelectElement("credentialsId"); credential != nil { + s.CredentialId = credential.Text() + } + if repoOwner := source.SelectElement("repoOwner"); repoOwner != nil { + s.Owner = repoOwner.Text() + } + if repository := source.SelectElement("repository"); repository != nil { + s.Repo = repository.Text() + } + if apiUri := source.SelectElement("serverUrl"); apiUri != nil { + s.ApiUri = apiUri.Text() + } + traits := source.SelectElement("traits") + if branchDiscoverTrait := traits.SelectElement( + "com.cloudbees.jenkins.plugins.bitbucket.BranchDiscoveryTrait"); branchDiscoverTrait != nil { + strategyId, _ := strconv.Atoi(branchDiscoverTrait.SelectElement("strategyId").Text()) + s.DiscoverBranches = strategyId + } + if tagDiscoverTrait := traits.SelectElement( + "com.cloudbees.jenkins.plugins.bitbucket.TagDiscoveryTrait"); tagDiscoverTrait != nil { + s.DiscoverTags = true + } + if originPRDiscoverTrait := traits.SelectElement( + "com.cloudbees.jenkins.plugins.bitbucket.OriginPullRequestDiscoveryTrait"); originPRDiscoverTrait != nil { + strategyId, _ := strconv.Atoi(originPRDiscoverTrait.SelectElement("strategyId").Text()) + s.DiscoverPRFromOrigin = strategyId + } + if forkPRDiscoverTrait := traits.SelectElement( + "com.cloudbees.jenkins.plugins.bitbucket.ForkPullRequestDiscoveryTrait"); forkPRDiscoverTrait != nil { + strategyId, _ := strconv.Atoi(forkPRDiscoverTrait.SelectElement("strategyId").Text()) + trustClass := forkPRDiscoverTrait.SelectElement("trust").SelectAttr("class").Value + trust := strings.Split(trustClass, "$") + + if prTrust := BitbucketPRDiscoverTrust(1).ParseFromString(trust[1]); prTrust.IsValid() { + s.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ + Strategy: strategyId, + Trust: prTrust.Value(), + } + } else { + klog.Warningf("invalid Bitbucket discover PR trust value: %s", trust[1]) + } + + if cloneTrait := traits.SelectElement( + "jenkins.plugins.git.traits.CloneOptionTrait"); cloneTrait != nil { + if cloneExtension := cloneTrait.SelectElement( + "extension"); cloneExtension != nil { + s.CloneOption = &devopsv1alpha3.GitCloneOption{} + if value, err := strconv.ParseBool(cloneExtension.SelectElement("shallow").Text()); err == nil { + s.CloneOption.Shallow = value + } + if value, err := strconv.ParseInt(cloneExtension.SelectElement("timeout").Text(), 10, 32); err == nil { + s.CloneOption.Timeout = int(value) + } + if value, err := strconv.ParseInt(cloneExtension.SelectElement("depth").Text(), 10, 32); err == nil { + s.CloneOption.Depth = int(value) + } + } + } + + if regexTrait := traits.SelectElement( + "jenkins.scm.impl.trait.RegexSCMHeadFilterTrait"); regexTrait != nil { + if regex := regexTrait.SelectElement("regex"); regex != nil { + s.RegexFilter = regex.Text() + } + } + } + return &s +} diff --git a/pkg/simple/client/devops/jenkins/internal/common_test.go b/pkg/simple/client/devops/jenkins/internal/common_test.go new file mode 100644 index 0000000000000000000000000000000000000000..b2aa5cc41b413ea17569e5828ef87092ccc2b56a --- /dev/null +++ b/pkg/simple/client/devops/jenkins/internal/common_test.go @@ -0,0 +1,14 @@ +package internal + +import "testing" + +func TestCommonSituation(t *testing.T) { + // make sure these functions do not panic + // I add these test cases because it's possible that users just do give the git source + AppendGitlabSourceToEtree(nil, nil) + AppendGithubSourceToEtree(nil, nil) + AppendBitbucketServerSourceToEtree(nil, nil) + AppendGitSourceToEtree(nil, nil) + AppendSingleSvnSourceToEtree(nil, nil) + AppendSvnSourceToEtree(nil, nil) +} diff --git a/pkg/simple/client/devops/jenkins/internal/git.go b/pkg/simple/client/devops/jenkins/internal/git.go new file mode 100644 index 0000000000000000000000000000000000000000..cf18965fb0452afdd849fa129f556544a18cdb70 --- /dev/null +++ b/pkg/simple/client/devops/jenkins/internal/git.go @@ -0,0 +1,98 @@ +package internal + +import ( + "github.com/beevik/etree" + "k8s.io/klog" + devopsv1alpha3 "kubesphere.io/kubesphere/pkg/apis/devops/v1alpha3" + "strconv" +) + +func AppendGitSourceToEtree(source *etree.Element, gitSource *devopsv1alpha3.GitSource) { + if gitSource == nil { + klog.Warning("please provide Git source when the sourceType is Git") + return + } + source.CreateAttr("class", "jenkins.plugins.git.GitSCMSource") + source.CreateAttr("plugin", "git") + source.CreateElement("id").SetText(gitSource.ScmId) + source.CreateElement("remote").SetText(gitSource.Url) + if gitSource.CredentialId != "" { + source.CreateElement("credentialsId").SetText(gitSource.CredentialId) + } + traits := source.CreateElement("traits") + if gitSource.DiscoverBranches { + traits.CreateElement("jenkins.plugins.git.traits.BranchDiscoveryTrait") + } + if gitSource.DiscoverTags { + traits.CreateElement("jenkins.plugins.git.traits.TagDiscoveryTrait") + } + if gitSource.CloneOption != nil { + cloneExtension := traits.CreateElement("jenkins.plugins.git.traits.CloneOptionTrait").CreateElement("extension") + cloneExtension.CreateAttr("class", "hudson.plugins.git.extensions.impl.CloneOption") + cloneExtension.CreateElement("shallow").SetText(strconv.FormatBool(gitSource.CloneOption.Shallow)) + cloneExtension.CreateElement("noTags").SetText(strconv.FormatBool(false)) + cloneExtension.CreateElement("honorRefspec").SetText(strconv.FormatBool(true)) + cloneExtension.CreateElement("reference") + if gitSource.CloneOption.Timeout >= 0 { + cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(gitSource.CloneOption.Timeout)) + } else { + cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(10)) + } + + if gitSource.CloneOption.Depth >= 0 { + cloneExtension.CreateElement("depth").SetText(strconv.Itoa(gitSource.CloneOption.Depth)) + } else { + cloneExtension.CreateElement("depth").SetText(strconv.Itoa(1)) + } + } + + if gitSource.RegexFilter != "" { + regexTraits := traits.CreateElement("jenkins.scm.impl.trait.RegexSCMHeadFilterTrait") + regexTraits.CreateAttr("plugin", "scm-api") + regexTraits.CreateElement("regex").SetText(gitSource.RegexFilter) + } + return +} + +func GetGitSourcefromEtree(source *etree.Element) *devopsv1alpha3.GitSource { + var gitSource devopsv1alpha3.GitSource + if credential := source.SelectElement("credentialsId"); credential != nil { + gitSource.CredentialId = credential.Text() + } + if remote := source.SelectElement("remote"); remote != nil { + gitSource.Url = remote.Text() + } + + traits := source.SelectElement("traits") + if branchDiscoverTrait := traits.SelectElement( + "jenkins.plugins.git.traits.BranchDiscoveryTrait"); branchDiscoverTrait != nil { + gitSource.DiscoverBranches = true + } + if tagDiscoverTrait := traits.SelectElement( + "jenkins.plugins.git.traits.TagDiscoveryTrait"); tagDiscoverTrait != nil { + gitSource.DiscoverTags = true + } + if cloneTrait := traits.SelectElement( + "jenkins.plugins.git.traits.CloneOptionTrait"); cloneTrait != nil { + if cloneExtension := cloneTrait.SelectElement( + "extension"); cloneExtension != nil { + gitSource.CloneOption = &devopsv1alpha3.GitCloneOption{} + if value, err := strconv.ParseBool(cloneExtension.SelectElement("shallow").Text()); err == nil { + gitSource.CloneOption.Shallow = value + } + if value, err := strconv.ParseInt(cloneExtension.SelectElement("timeout").Text(), 10, 32); err == nil { + gitSource.CloneOption.Timeout = int(value) + } + if value, err := strconv.ParseInt(cloneExtension.SelectElement("depth").Text(), 10, 32); err == nil { + gitSource.CloneOption.Depth = int(value) + } + } + } + if regexTrait := traits.SelectElement( + "jenkins.scm.impl.trait.RegexSCMHeadFilterTrait"); regexTrait != nil { + if regex := regexTrait.SelectElement("regex"); regex != nil { + gitSource.RegexFilter = regex.Text() + } + } + return &gitSource +} diff --git a/pkg/simple/client/devops/jenkins/internal/github.go b/pkg/simple/client/devops/jenkins/internal/github.go new file mode 100644 index 0000000000000000000000000000000000000000..1a4fb1e176ab2274bbcf59695b58510c6a26828b --- /dev/null +++ b/pkg/simple/client/devops/jenkins/internal/github.go @@ -0,0 +1,142 @@ +package internal + +import ( + "github.com/beevik/etree" + "k8s.io/klog" + devopsv1alpha3 "kubesphere.io/kubesphere/pkg/apis/devops/v1alpha3" + "strconv" + "strings" +) + +func AppendGithubSourceToEtree(source *etree.Element, githubSource *devopsv1alpha3.GithubSource) { + if githubSource == nil { + klog.Warning("please provide GitHub source when the sourceType is GitHub") + return + } + source.CreateAttr("class", "org.jenkinsci.plugins.github_branch_source.GitHubSCMSource") + source.CreateAttr("plugin", "github-branch-source") + source.CreateElement("id").SetText(githubSource.ScmId) + source.CreateElement("credentialsId").SetText(githubSource.CredentialId) + source.CreateElement("repoOwner").SetText(githubSource.Owner) + source.CreateElement("repository").SetText(githubSource.Repo) + if githubSource.ApiUri != "" { + source.CreateElement("apiUri").SetText(githubSource.ApiUri) + } + traits := source.CreateElement("traits") + if githubSource.DiscoverBranches != 0 { + traits.CreateElement("org.jenkinsci.plugins.github__branch__source.BranchDiscoveryTrait"). + CreateElement("strategyId").SetText(strconv.Itoa(githubSource.DiscoverBranches)) + } + if githubSource.DiscoverPRFromOrigin != 0 { + traits.CreateElement("org.jenkinsci.plugins.github__branch__source.OriginPullRequestDiscoveryTrait"). + CreateElement("strategyId").SetText(strconv.Itoa(githubSource.DiscoverPRFromOrigin)) + } + if githubSource.DiscoverPRFromForks != nil { + forkTrait := traits.CreateElement("org.jenkinsci.plugins.github__branch__source.ForkPullRequestDiscoveryTrait") + forkTrait.CreateElement("strategyId").SetText(strconv.Itoa(githubSource.DiscoverPRFromForks.Strategy)) + trustClass := "org.jenkinsci.plugins.github_branch_source.ForkPullRequestDiscoveryTrait$" + if prTrust := GitHubPRDiscoverTrust(githubSource.DiscoverPRFromForks.Trust); prTrust.IsValid() { + trustClass += prTrust.String() + } else { + klog.Warningf("invalid GitHub discover PR trust value: %d", prTrust.Value()) + } + forkTrait.CreateElement("trust").CreateAttr("class", trustClass) + } + if githubSource.DiscoverTags { + traits.CreateElement("org.jenkinsci.plugins.github__branch__source.TagDiscoveryTrait") + } + if githubSource.CloneOption != nil { + cloneExtension := traits.CreateElement("jenkins.plugins.git.traits.CloneOptionTrait").CreateElement("extension") + cloneExtension.CreateAttr("class", "hudson.plugins.git.extensions.impl.CloneOption") + cloneExtension.CreateElement("shallow").SetText(strconv.FormatBool(githubSource.CloneOption.Shallow)) + cloneExtension.CreateElement("noTags").SetText(strconv.FormatBool(false)) + cloneExtension.CreateElement("honorRefspec").SetText(strconv.FormatBool(true)) + cloneExtension.CreateElement("reference") + if githubSource.CloneOption.Timeout >= 0 { + cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(githubSource.CloneOption.Timeout)) + } else { + cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(10)) + } + + if githubSource.CloneOption.Depth >= 0 { + cloneExtension.CreateElement("depth").SetText(strconv.Itoa(githubSource.CloneOption.Depth)) + } else { + cloneExtension.CreateElement("depth").SetText(strconv.Itoa(1)) + } + } + if githubSource.RegexFilter != "" { + regexTraits := traits.CreateElement("jenkins.scm.impl.trait.RegexSCMHeadFilterTrait") + regexTraits.CreateAttr("plugin", "scm-api") + regexTraits.CreateElement("regex").SetText(githubSource.RegexFilter) + } + return +} + +func GetGithubSourcefromEtree(source *etree.Element) *devopsv1alpha3.GithubSource { + var githubSource devopsv1alpha3.GithubSource + if credential := source.SelectElement("credentialsId"); credential != nil { + githubSource.CredentialId = credential.Text() + } + if repoOwner := source.SelectElement("repoOwner"); repoOwner != nil { + githubSource.Owner = repoOwner.Text() + } + if repository := source.SelectElement("repository"); repository != nil { + githubSource.Repo = repository.Text() + } + if apiUri := source.SelectElement("apiUri"); apiUri != nil { + githubSource.ApiUri = apiUri.Text() + } + traits := source.SelectElement("traits") + if branchDiscoverTrait := traits.SelectElement( + "org.jenkinsci.plugins.github__branch__source.BranchDiscoveryTrait"); branchDiscoverTrait != nil { + strategyId, _ := strconv.Atoi(branchDiscoverTrait.SelectElement("strategyId").Text()) + githubSource.DiscoverBranches = strategyId + } + if tagDiscoverTrait := traits.SelectElement( + "org.jenkinsci.plugins.github__branch__source.TagDiscoveryTrait"); tagDiscoverTrait != nil { + githubSource.DiscoverTags = true + } + if originPRDiscoverTrait := traits.SelectElement( + "org.jenkinsci.plugins.github__branch__source.OriginPullRequestDiscoveryTrait"); originPRDiscoverTrait != nil { + strategyId, _ := strconv.Atoi(originPRDiscoverTrait.SelectElement("strategyId").Text()) + githubSource.DiscoverPRFromOrigin = strategyId + } + if forkPRDiscoverTrait := traits.SelectElement( + "org.jenkinsci.plugins.github__branch__source.ForkPullRequestDiscoveryTrait"); forkPRDiscoverTrait != nil { + strategyId, _ := strconv.Atoi(forkPRDiscoverTrait.SelectElement("strategyId").Text()) + trustClass := forkPRDiscoverTrait.SelectElement("trust").SelectAttr("class").Value + trust := strings.Split(trustClass, "$") + if prTrust := GitHubPRDiscoverTrust(1).ParseFromString(trust[1]); prTrust.IsValid() { + githubSource.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ + Strategy: strategyId, + Trust: prTrust.Value(), + } + } else { + klog.Warningf("invalid Gitlab discover PR trust value: %s", trust[1]) + } + if cloneTrait := traits.SelectElement( + "jenkins.plugins.git.traits.CloneOptionTrait"); cloneTrait != nil { + if cloneExtension := cloneTrait.SelectElement( + "extension"); cloneExtension != nil { + githubSource.CloneOption = &devopsv1alpha3.GitCloneOption{} + if value, err := strconv.ParseBool(cloneExtension.SelectElement("shallow").Text()); err == nil { + githubSource.CloneOption.Shallow = value + } + if value, err := strconv.ParseInt(cloneExtension.SelectElement("timeout").Text(), 10, 32); err == nil { + githubSource.CloneOption.Timeout = int(value) + } + if value, err := strconv.ParseInt(cloneExtension.SelectElement("depth").Text(), 10, 32); err == nil { + githubSource.CloneOption.Depth = int(value) + } + } + } + + if regexTrait := traits.SelectElement( + "jenkins.scm.impl.trait.RegexSCMHeadFilterTrait"); regexTrait != nil { + if regex := regexTrait.SelectElement("regex"); regex != nil { + githubSource.RegexFilter = regex.Text() + } + } + } + return &githubSource +} diff --git a/pkg/simple/client/devops/jenkins/internal/gitlab.go b/pkg/simple/client/devops/jenkins/internal/gitlab.go index a515b9b215a51c205269e2b7e7070ca40eb3156e..d37ffea5fa7e2de44094a1943f84009cb9526480 100644 --- a/pkg/simple/client/devops/jenkins/internal/gitlab.go +++ b/pkg/simple/client/devops/jenkins/internal/gitlab.go @@ -2,12 +2,17 @@ package internal import ( "github.com/beevik/etree" + "k8s.io/klog" devopsv1alpha3 "kubesphere.io/kubesphere/pkg/apis/devops/v1alpha3" "strconv" "strings" ) func AppendGitlabSourceToEtree(source *etree.Element, gitSource *devopsv1alpha3.GitlabSource) { + if gitSource == nil { + klog.Warning("please provide Gitlab source when the sourceType is Gitlab") + return + } source.CreateAttr("class", "io.jenkins.plugins.gitlabbranchsource.GitLabSCMSource") source.CreateAttr("plugin", "gitlab-branch-source") source.CreateElement("id").SetText(gitSource.ScmId) @@ -31,15 +36,11 @@ func AppendGitlabSourceToEtree(source *etree.Element, gitSource *devopsv1alpha3. forkTrait := traits.CreateElement("io.jenkins.plugins.gitlabbranchsource.ForkMergeRequestDiscoveryTrait") forkTrait.CreateElement("strategyId").SetText(strconv.Itoa(gitSource.DiscoverPRFromForks.Strategy)) trustClass := "io.jenkins.plugins.gitlabbranchsource.ForkMergeRequestDiscoveryTrait$" - switch gitSource.DiscoverPRFromForks.Trust { - case 1: - trustClass += "TrustMembers" // it's difference with GitHub - case 2: - trustClass += "TrustEveryone" - case 3: - trustClass += "TrustPermission" - case 4: - trustClass += "TrustNobody" + + if prTrust := PRDiscoverTrust(gitSource.DiscoverPRFromForks.Trust); prTrust.IsValid() { + trustClass += prTrust.String() + } else { + klog.Warningf("invalid Gitlab discover PR trust value: %d", prTrust.Value()) } forkTrait.CreateElement("trust").CreateAttr("class", trustClass) } @@ -64,7 +65,7 @@ func AppendGitlabSourceToEtree(source *etree.Element, gitSource *devopsv1alpha3. } if gitSource.RegexFilter != "" { regexTraits := traits.CreateElement("jenkins.scm.impl.trait.RegexSCMHeadFilterTrait") - regexTraits.CreateAttr("plugin", "scm-api@2.4.0") + regexTraits.CreateAttr("plugin", "scm-api") regexTraits.CreateElement("regex").SetText(gitSource.RegexFilter) } return @@ -104,27 +105,13 @@ func GetGitlabSourceFromEtree(source *etree.Element) (gitSource *devopsv1alpha3. strategyId, _ := strconv.Atoi(forkPRDiscoverTrait.SelectElement("strategyId").Text()) trustClass := forkPRDiscoverTrait.SelectElement("trust").SelectAttr("class").Value trust := strings.Split(trustClass, "$") - switch trust[1] { - case "TrustMembers": // it's difference with GitHub + if prTrust := PRDiscoverTrust(1).ParseFromString(trust[1]); prTrust.IsValid() { gitSource.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ Strategy: strategyId, - Trust: 1, - } - case "TrustEveryone": - gitSource.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 2, - } - case "TrustPermission": - gitSource.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 3, - } - case "TrustNobody": - gitSource.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 4, + Trust: prTrust.Value(), } + } else { + klog.Warningf("invalid Gitlab discover PR trust value: %s", trust[1]) } if cloneTrait := traits.SelectElement( "jenkins.plugins.git.traits.CloneOptionTrait"); cloneTrait != nil { diff --git a/pkg/simple/client/devops/jenkins/internal/pull_request.go b/pkg/simple/client/devops/jenkins/internal/pull_request.go new file mode 100644 index 0000000000000000000000000000000000000000..b5b7993e4a80d67298dd8ca630fbbfaef3e0f35f --- /dev/null +++ b/pkg/simple/client/devops/jenkins/internal/pull_request.go @@ -0,0 +1,124 @@ +package internal + +type PRDiscoverTrust int + +const ( + PRDiscoverTrustMember PRDiscoverTrust = 1 + PRDiscoverTrustEveryone PRDiscoverTrust = 2 + PRDiscoverTrustPermission PRDiscoverTrust = 3 + PRDiscoverTrustNobody PRDiscoverTrust = 4 + PRDiscoverUnknown PRDiscoverTrust = -1 +) + +func (p PRDiscoverTrust) Value() int { + return int(p) +} + +func (p PRDiscoverTrust) String() string { + switch p { + case PRDiscoverTrustMember: + return "TrustMembers" + case PRDiscoverTrustEveryone: + return "TrustEveryone" + case PRDiscoverTrustPermission: + return "TrustPermission" + case PRDiscoverTrustNobody: + return "TrustNobody" + } + return "" +} + +func (p PRDiscoverTrust) ParseFromString(prTrust string) PRDiscoverTrust { + switch prTrust { + case "TrustMembers": + return PRDiscoverTrustMember + case "TrustEveryone": + return PRDiscoverTrustEveryone + case "TrustPermission": + return PRDiscoverTrustPermission + case "TrustNobody": + return PRDiscoverTrustNobody + default: + return PRDiscoverUnknown + } +} + +// GitHub +type GitHubPRDiscoverTrust int + +const ( + GitHubPRDiscoverTrustContributors GitHubPRDiscoverTrust = 1 +) + +func (p GitHubPRDiscoverTrust) Value() int { + return int(p) +} + +func (p PRDiscoverTrust) IsValid() bool { + return p.String() != "" +} + +func (p GitHubPRDiscoverTrust) String() string { + switch p { + case GitHubPRDiscoverTrustContributors: + return "TrustContributors" + default: + return PRDiscoverTrust(p).String() + } +} + +func (p GitHubPRDiscoverTrust) ParseFromString(prTrust string) GitHubPRDiscoverTrust { + switch prTrust { + case "TrustContributors": + return GitHubPRDiscoverTrustContributors + default: + return GitHubPRDiscoverTrust(PRDiscoverTrust(p).ParseFromString(prTrust)) + } +} + +func (p GitHubPRDiscoverTrust) IsValid() bool { + return PRDiscoverTrust(p).IsValid() +} + +// Bitbucket +type BitbucketPRDiscoverTrust int + +const ( + BitbucketPRDiscoverTrustEveryone BitbucketPRDiscoverTrust = 1 + BitbucketPRDiscoverTrustTeamForks BitbucketPRDiscoverTrust = 2 + BitbucketPRDiscoverTrustNobody BitbucketPRDiscoverTrust = 3 +) + +func (p BitbucketPRDiscoverTrust) Value() int { + return int(p) +} + +func (p BitbucketPRDiscoverTrust) IsValid() bool { + return p.String() != "" +} + +func (p BitbucketPRDiscoverTrust) String() string { + switch p { + default: + fallthrough + case BitbucketPRDiscoverTrustEveryone: + return "TrustEveryone" + case BitbucketPRDiscoverTrustTeamForks: + return "TrustTeamForks" + case BitbucketPRDiscoverTrustNobody: + return "TrustNobody" + } +} + +func (p BitbucketPRDiscoverTrust) ParseFromString(prTrust string) BitbucketPRDiscoverTrust { + switch prTrust { + default: + fallthrough + case "TrustEveryone": + return BitbucketPRDiscoverTrustEveryone + case "TrustTeamForks": + return BitbucketPRDiscoverTrustTeamForks + case "TrustNobody": + return BitbucketPRDiscoverTrustNobody + } +} diff --git a/pkg/simple/client/devops/jenkins/internal/pull_request_test.go b/pkg/simple/client/devops/jenkins/internal/pull_request_test.go new file mode 100644 index 0000000000000000000000000000000000000000..04e15a516d656fc1b340d6784e227f47aa1c996c --- /dev/null +++ b/pkg/simple/client/devops/jenkins/internal/pull_request_test.go @@ -0,0 +1,41 @@ +package internal + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func TestPRDiscoverTrust(t *testing.T) { + assert.Equal(t, PRDiscoverTrust(1).String(), "TrustMembers") + assert.Equal(t, PRDiscoverTrust(2).String(), "TrustEveryone") + assert.Equal(t, PRDiscoverTrust(3).String(), "TrustPermission") + assert.Equal(t, PRDiscoverTrust(4).String(), "TrustNobody") + assert.Equal(t, PRDiscoverTrust(-1).IsValid(), false) + assert.Equal(t, PRDiscoverTrust(1).Value(), 1) + + assert.Equal(t, PRDiscoverTrust(1).ParseFromString("TrustMembers"), PRDiscoverTrustMember) + assert.Equal(t, PRDiscoverTrust(1).ParseFromString("TrustEveryone"), PRDiscoverTrustEveryone) + assert.Equal(t, PRDiscoverTrust(1).ParseFromString("TrustPermission"), PRDiscoverTrustPermission) + assert.Equal(t, PRDiscoverTrust(1).ParseFromString("TrustNobody"), PRDiscoverTrustNobody) + assert.Equal(t, PRDiscoverTrust(1).ParseFromString("fake").IsValid(), false) + + // GitHub + assert.Equal(t, GitHubPRDiscoverTrust(1).String(), "TrustContributors") + assert.Equal(t, GitHubPRDiscoverTrust(2).String(), PRDiscoverTrust(2).String()) + assert.Equal(t, GitHubPRDiscoverTrust(1).Value(), 1) + assert.Equal(t, GitHubPRDiscoverTrust(1).ParseFromString("TrustContributors"), GitHubPRDiscoverTrustContributors) + assert.Equal(t, GitHubPRDiscoverTrust(1).ParseFromString("TrustEveryone").String(), "TrustEveryone") + assert.Equal(t, GitHubPRDiscoverTrust(1).ParseFromString("fake").IsValid(), false) + + // Bithucket + assert.Equal(t, BitbucketPRDiscoverTrust(1).String(), "TrustEveryone") + assert.Equal(t, BitbucketPRDiscoverTrust(2).String(), "TrustTeamForks") + assert.Equal(t, BitbucketPRDiscoverTrust(3).String(), "TrustNobody") + assert.Equal(t, BitbucketPRDiscoverTrust(3).Value(), 3) + assert.Equal(t, BitbucketPRDiscoverTrust(-1).String(), "TrustEveryone") + assert.Equal(t, BitbucketPRDiscoverTrust(1).ParseFromString("TrustEveryone"), BitbucketPRDiscoverTrustEveryone) + assert.Equal(t, BitbucketPRDiscoverTrust(1).ParseFromString("TrustTeamForks"), BitbucketPRDiscoverTrustTeamForks) + assert.Equal(t, BitbucketPRDiscoverTrust(1).ParseFromString("TrustNobody"), BitbucketPRDiscoverTrustNobody) + assert.Equal(t, BitbucketPRDiscoverTrust(1).ParseFromString("fake"), BitbucketPRDiscoverTrustEveryone) + assert.Equal(t, BitbucketPRDiscoverTrust(1).ParseFromString("TrustNobody").IsValid(), true) +} diff --git a/pkg/simple/client/devops/jenkins/internal/svn.go b/pkg/simple/client/devops/jenkins/internal/svn.go new file mode 100644 index 0000000000000000000000000000000000000000..e4d2e8d89426fdd56c9a7de7c6a688e3c6f562f7 --- /dev/null +++ b/pkg/simple/client/devops/jenkins/internal/svn.go @@ -0,0 +1,107 @@ +package internal + +import ( + "github.com/beevik/etree" + "k8s.io/klog" + + devopsv1alpha3 "kubesphere.io/kubesphere/pkg/apis/devops/v1alpha3" +) + +func AppendSvnSourceToEtree(source *etree.Element, svnSource *devopsv1alpha3.SvnSource) { + if svnSource == nil { + klog.Warning("please provide SVN source when the sourceType is SVN") + return + } + source.CreateAttr("class", "jenkins.scm.impl.subversion.SubversionSCMSource") + source.CreateAttr("plugin", "subversion") + source.CreateElement("id").SetText(svnSource.ScmId) + if svnSource.CredentialId != "" { + source.CreateElement("credentialsId").SetText(svnSource.CredentialId) + } + if svnSource.Remote != "" { + source.CreateElement("remoteBase").SetText(svnSource.Remote) + } + if svnSource.Includes != "" { + source.CreateElement("includes").SetText(svnSource.Includes) + } + if svnSource.Excludes != "" { + source.CreateElement("excludes").SetText(svnSource.Excludes) + } + return +} + +func AppendSingleSvnSourceToEtree(source *etree.Element, svnSource *devopsv1alpha3.SingleSvnSource) { + if svnSource == nil { + klog.Warning("please provide SingleSvn source when the sourceType is SingleSvn") + return + } + source.CreateAttr("class", "jenkins.scm.impl.SingleSCMSource") + source.CreateAttr("plugin", "scm-api") + source.CreateElement("id").SetText(svnSource.ScmId) + source.CreateElement("name").SetText("master") + + scm := source.CreateElement("scm") + scm.CreateAttr("class", "hudson.scm.SubversionSCM") + scm.CreateAttr("plugin", "subversion") + + location := scm.CreateElement("locations").CreateElement("hudson.scm.SubversionSCM_-ModuleLocation") + if svnSource.Remote != "" { + location.CreateElement("remote").SetText(svnSource.Remote) + } + if svnSource.CredentialId != "" { + location.CreateElement("credentialsId").SetText(svnSource.CredentialId) + } + location.CreateElement("local").SetText(".") + location.CreateElement("depthOption").SetText("infinity") + location.CreateElement("ignoreExternalsOption").SetText("true") + location.CreateElement("cancelProcessOnExternalsFail").SetText("true") + + source.CreateElement("excludedRegions") + source.CreateElement("includedRegions") + source.CreateElement("excludedUsers") + source.CreateElement("excludedRevprop") + source.CreateElement("excludedCommitMessages") + source.CreateElement("workspaceUpdater").CreateAttr("class", "hudson.scm.subversion.UpdateUpdater") + source.CreateElement("ignoreDirPropChanges").SetText("false") + source.CreateElement("filterChangelog").SetText("false") + source.CreateElement("quietOperation").SetText("true") + + return +} + +func GetSingleSvnSourceFromEtree(source *etree.Element) *devopsv1alpha3.SingleSvnSource { + var s devopsv1alpha3.SingleSvnSource + if scm := source.SelectElement("scm"); scm != nil { + if locations := scm.SelectElement("locations"); locations != nil { + if moduleLocations := locations.SelectElement("hudson.scm.SubversionSCM_-ModuleLocation"); moduleLocations != nil { + if remote := moduleLocations.SelectElement("remote"); remote != nil { + s.Remote = remote.Text() + } + if credentialId := moduleLocations.SelectElement("credentialsId"); credentialId != nil { + s.CredentialId = credentialId.Text() + } + } + } + } + return &s +} + +func GetSvnSourcefromEtree(source *etree.Element) *devopsv1alpha3.SvnSource { + var s devopsv1alpha3.SvnSource + if remote := source.SelectElement("remoteBase"); remote != nil { + s.Remote = remote.Text() + } + + if credentialsId := source.SelectElement("credentialsId"); credentialsId != nil { + s.CredentialId = credentialsId.Text() + } + + if includes := source.SelectElement("includes"); includes != nil { + s.Includes = includes.Text() + } + + if excludes := source.SelectElement("excludes"); excludes != nil { + s.Excludes = excludes.Text() + } + return &s +} diff --git a/pkg/simple/client/devops/jenkins/pipeline_internal.go b/pkg/simple/client/devops/jenkins/pipeline_internal.go index a6c12e73f1b770d1980412ee9358d536daee4fc3..04e3a4ea28bcb5cab93908d4675e2945c758fd57 100644 --- a/pkg/simple/client/devops/jenkins/pipeline_internal.go +++ b/pkg/simple/client/devops/jenkins/pipeline_internal.go @@ -251,475 +251,6 @@ func getParametersfromEtree(properties *etree.Element) []devopsv1alpha3.Paramete return parameters } -func appendGitSourceToEtree(source *etree.Element, gitSource *devopsv1alpha3.GitSource) { - source.CreateAttr("class", "jenkins.plugins.git.GitSCMSource") - source.CreateAttr("plugin", "git") - source.CreateElement("id").SetText(gitSource.ScmId) - source.CreateElement("remote").SetText(gitSource.Url) - if gitSource.CredentialId != "" { - source.CreateElement("credentialsId").SetText(gitSource.CredentialId) - } - traits := source.CreateElement("traits") - if gitSource.DiscoverBranches { - traits.CreateElement("jenkins.plugins.git.traits.BranchDiscoveryTrait") - } - if gitSource.DiscoverTags { - traits.CreateElement("jenkins.plugins.git.traits.TagDiscoveryTrait") - } - if gitSource.CloneOption != nil { - cloneExtension := traits.CreateElement("jenkins.plugins.git.traits.CloneOptionTrait").CreateElement("extension") - cloneExtension.CreateAttr("class", "hudson.plugins.git.extensions.impl.CloneOption") - cloneExtension.CreateElement("shallow").SetText(strconv.FormatBool(gitSource.CloneOption.Shallow)) - cloneExtension.CreateElement("noTags").SetText(strconv.FormatBool(false)) - cloneExtension.CreateElement("honorRefspec").SetText(strconv.FormatBool(true)) - cloneExtension.CreateElement("reference") - if gitSource.CloneOption.Timeout >= 0 { - cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(gitSource.CloneOption.Timeout)) - } else { - cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(10)) - } - - if gitSource.CloneOption.Depth >= 0 { - cloneExtension.CreateElement("depth").SetText(strconv.Itoa(gitSource.CloneOption.Depth)) - } else { - cloneExtension.CreateElement("depth").SetText(strconv.Itoa(1)) - } - } - - if gitSource.RegexFilter != "" { - regexTraits := traits.CreateElement("jenkins.scm.impl.trait.RegexSCMHeadFilterTrait") - regexTraits.CreateAttr("plugin", "scm-api@2.4.0") - regexTraits.CreateElement("regex").SetText(gitSource.RegexFilter) - } - return -} - -func getGitSourcefromEtree(source *etree.Element) *devopsv1alpha3.GitSource { - var gitSource devopsv1alpha3.GitSource - if credential := source.SelectElement("credentialsId"); credential != nil { - gitSource.CredentialId = credential.Text() - } - if remote := source.SelectElement("remote"); remote != nil { - gitSource.Url = remote.Text() - } - - traits := source.SelectElement("traits") - if branchDiscoverTrait := traits.SelectElement( - "jenkins.plugins.git.traits.BranchDiscoveryTrait"); branchDiscoverTrait != nil { - gitSource.DiscoverBranches = true - } - if tagDiscoverTrait := traits.SelectElement( - "jenkins.plugins.git.traits.TagDiscoveryTrait"); tagDiscoverTrait != nil { - gitSource.DiscoverTags = true - } - if cloneTrait := traits.SelectElement( - "jenkins.plugins.git.traits.CloneOptionTrait"); cloneTrait != nil { - if cloneExtension := cloneTrait.SelectElement( - "extension"); cloneExtension != nil { - gitSource.CloneOption = &devopsv1alpha3.GitCloneOption{} - if value, err := strconv.ParseBool(cloneExtension.SelectElement("shallow").Text()); err == nil { - gitSource.CloneOption.Shallow = value - } - if value, err := strconv.ParseInt(cloneExtension.SelectElement("timeout").Text(), 10, 32); err == nil { - gitSource.CloneOption.Timeout = int(value) - } - if value, err := strconv.ParseInt(cloneExtension.SelectElement("depth").Text(), 10, 32); err == nil { - gitSource.CloneOption.Depth = int(value) - } - } - } - if regexTrait := traits.SelectElement( - "jenkins.scm.impl.trait.RegexSCMHeadFilterTrait"); regexTrait != nil { - if regex := regexTrait.SelectElement("regex"); regex != nil { - gitSource.RegexFilter = regex.Text() - } - } - return &gitSource -} - -func getGithubSourcefromEtree(source *etree.Element) *devopsv1alpha3.GithubSource { - var githubSource devopsv1alpha3.GithubSource - if credential := source.SelectElement("credentialsId"); credential != nil { - githubSource.CredentialId = credential.Text() - } - if repoOwner := source.SelectElement("repoOwner"); repoOwner != nil { - githubSource.Owner = repoOwner.Text() - } - if repository := source.SelectElement("repository"); repository != nil { - githubSource.Repo = repository.Text() - } - if apiUri := source.SelectElement("apiUri"); apiUri != nil { - githubSource.ApiUri = apiUri.Text() - } - traits := source.SelectElement("traits") - if branchDiscoverTrait := traits.SelectElement( - "org.jenkinsci.plugins.github__branch__source.BranchDiscoveryTrait"); branchDiscoverTrait != nil { - strategyId, _ := strconv.Atoi(branchDiscoverTrait.SelectElement("strategyId").Text()) - githubSource.DiscoverBranches = strategyId - } - if tagDiscoverTrait := traits.SelectElement( - "org.jenkinsci.plugins.github__branch__source.TagDiscoveryTrait"); tagDiscoverTrait != nil { - githubSource.DiscoverTags = true - } - if originPRDiscoverTrait := traits.SelectElement( - "org.jenkinsci.plugins.github__branch__source.OriginPullRequestDiscoveryTrait"); originPRDiscoverTrait != nil { - strategyId, _ := strconv.Atoi(originPRDiscoverTrait.SelectElement("strategyId").Text()) - githubSource.DiscoverPRFromOrigin = strategyId - } - if forkPRDiscoverTrait := traits.SelectElement( - "org.jenkinsci.plugins.github__branch__source.ForkPullRequestDiscoveryTrait"); forkPRDiscoverTrait != nil { - strategyId, _ := strconv.Atoi(forkPRDiscoverTrait.SelectElement("strategyId").Text()) - trustClass := forkPRDiscoverTrait.SelectElement("trust").SelectAttr("class").Value - trust := strings.Split(trustClass, "$") - switch trust[1] { - case "TrustContributors": - githubSource.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 1, - } - case "TrustEveryone": - githubSource.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 2, - } - case "TrustPermission": - githubSource.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 3, - } - case "TrustNobody": - githubSource.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 4, - } - } - if cloneTrait := traits.SelectElement( - "jenkins.plugins.git.traits.CloneOptionTrait"); cloneTrait != nil { - if cloneExtension := cloneTrait.SelectElement( - "extension"); cloneExtension != nil { - githubSource.CloneOption = &devopsv1alpha3.GitCloneOption{} - if value, err := strconv.ParseBool(cloneExtension.SelectElement("shallow").Text()); err == nil { - githubSource.CloneOption.Shallow = value - } - if value, err := strconv.ParseInt(cloneExtension.SelectElement("timeout").Text(), 10, 32); err == nil { - githubSource.CloneOption.Timeout = int(value) - } - if value, err := strconv.ParseInt(cloneExtension.SelectElement("depth").Text(), 10, 32); err == nil { - githubSource.CloneOption.Depth = int(value) - } - } - } - - if regexTrait := traits.SelectElement( - "jenkins.scm.impl.trait.RegexSCMHeadFilterTrait"); regexTrait != nil { - if regex := regexTrait.SelectElement("regex"); regex != nil { - githubSource.RegexFilter = regex.Text() - } - } - } - return &githubSource -} - -func appendGithubSourceToEtree(source *etree.Element, githubSource *devopsv1alpha3.GithubSource) { - source.CreateAttr("class", "org.jenkinsci.plugins.github_branch_source.GitHubSCMSource") - source.CreateAttr("plugin", "github-branch-source") - source.CreateElement("id").SetText(githubSource.ScmId) - source.CreateElement("credentialsId").SetText(githubSource.CredentialId) - source.CreateElement("repoOwner").SetText(githubSource.Owner) - source.CreateElement("repository").SetText(githubSource.Repo) - if githubSource.ApiUri != "" { - source.CreateElement("apiUri").SetText(githubSource.ApiUri) - } - traits := source.CreateElement("traits") - if githubSource.DiscoverBranches != 0 { - traits.CreateElement("org.jenkinsci.plugins.github__branch__source.BranchDiscoveryTrait"). - CreateElement("strategyId").SetText(strconv.Itoa(githubSource.DiscoverBranches)) - } - if githubSource.DiscoverPRFromOrigin != 0 { - traits.CreateElement("org.jenkinsci.plugins.github__branch__source.OriginPullRequestDiscoveryTrait"). - CreateElement("strategyId").SetText(strconv.Itoa(githubSource.DiscoverPRFromOrigin)) - } - if githubSource.DiscoverPRFromForks != nil { - forkTrait := traits.CreateElement("org.jenkinsci.plugins.github__branch__source.ForkPullRequestDiscoveryTrait") - forkTrait.CreateElement("strategyId").SetText(strconv.Itoa(githubSource.DiscoverPRFromForks.Strategy)) - trustClass := "org.jenkinsci.plugins.github_branch_source.ForkPullRequestDiscoveryTrait$" - switch githubSource.DiscoverPRFromForks.Trust { - case 1: - trustClass += "TrustContributors" - case 2: - trustClass += "TrustEveryone" - case 3: - trustClass += "TrustPermission" - case 4: - trustClass += "TrustNobody" - default: - } - forkTrait.CreateElement("trust").CreateAttr("class", trustClass) - } - if githubSource.DiscoverTags { - traits.CreateElement("org.jenkinsci.plugins.github__branch__source.TagDiscoveryTrait") - } - if githubSource.CloneOption != nil { - cloneExtension := traits.CreateElement("jenkins.plugins.git.traits.CloneOptionTrait").CreateElement("extension") - cloneExtension.CreateAttr("class", "hudson.plugins.git.extensions.impl.CloneOption") - cloneExtension.CreateElement("shallow").SetText(strconv.FormatBool(githubSource.CloneOption.Shallow)) - cloneExtension.CreateElement("noTags").SetText(strconv.FormatBool(false)) - cloneExtension.CreateElement("honorRefspec").SetText(strconv.FormatBool(true)) - cloneExtension.CreateElement("reference") - if githubSource.CloneOption.Timeout >= 0 { - cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(githubSource.CloneOption.Timeout)) - } else { - cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(10)) - } - - if githubSource.CloneOption.Depth >= 0 { - cloneExtension.CreateElement("depth").SetText(strconv.Itoa(githubSource.CloneOption.Depth)) - } else { - cloneExtension.CreateElement("depth").SetText(strconv.Itoa(1)) - } - } - if githubSource.RegexFilter != "" { - regexTraits := traits.CreateElement("jenkins.scm.impl.trait.RegexSCMHeadFilterTrait") - regexTraits.CreateAttr("plugin", "scm-api@2.4.0") - regexTraits.CreateElement("regex").SetText(githubSource.RegexFilter) - } - return -} - -func getBitbucketServerSourceFromEtree(source *etree.Element) *devopsv1alpha3.BitbucketServerSource { - var s devopsv1alpha3.BitbucketServerSource - if credential := source.SelectElement("credentialsId"); credential != nil { - s.CredentialId = credential.Text() - } - if repoOwner := source.SelectElement("repoOwner"); repoOwner != nil { - s.Owner = repoOwner.Text() - } - if repository := source.SelectElement("repository"); repository != nil { - s.Repo = repository.Text() - } - if apiUri := source.SelectElement("serverUrl"); apiUri != nil { - s.ApiUri = apiUri.Text() - } - traits := source.SelectElement("traits") - if branchDiscoverTrait := traits.SelectElement( - "com.cloudbees.jenkins.plugins.bitbucket.BranchDiscoveryTrait"); branchDiscoverTrait != nil { - strategyId, _ := strconv.Atoi(branchDiscoverTrait.SelectElement("strategyId").Text()) - s.DiscoverBranches = strategyId - } - if tagDiscoverTrait := traits.SelectElement( - "com.cloudbees.jenkins.plugins.bitbucket.TagDiscoveryTrait"); tagDiscoverTrait != nil { - s.DiscoverTags = true - } - if originPRDiscoverTrait := traits.SelectElement( - "com.cloudbees.jenkins.plugins.bitbucket.OriginPullRequestDiscoveryTrait"); originPRDiscoverTrait != nil { - strategyId, _ := strconv.Atoi(originPRDiscoverTrait.SelectElement("strategyId").Text()) - s.DiscoverPRFromOrigin = strategyId - } - if forkPRDiscoverTrait := traits.SelectElement( - "com.cloudbees.jenkins.plugins.bitbucket.ForkPullRequestDiscoveryTrait"); forkPRDiscoverTrait != nil { - strategyId, _ := strconv.Atoi(forkPRDiscoverTrait.SelectElement("strategyId").Text()) - trustClass := forkPRDiscoverTrait.SelectElement("trust").SelectAttr("class").Value - trust := strings.Split(trustClass, "$") - switch trust[1] { - case "TrustEveryone": - s.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 1, - } - case "TrustTeamForks": - s.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 2, - } - case "TrustNobody": - s.DiscoverPRFromForks = &devopsv1alpha3.DiscoverPRFromForks{ - Strategy: strategyId, - Trust: 3, - } - } - if cloneTrait := traits.SelectElement( - "jenkins.plugins.git.traits.CloneOptionTrait"); cloneTrait != nil { - if cloneExtension := cloneTrait.SelectElement( - "extension"); cloneExtension != nil { - s.CloneOption = &devopsv1alpha3.GitCloneOption{} - if value, err := strconv.ParseBool(cloneExtension.SelectElement("shallow").Text()); err == nil { - s.CloneOption.Shallow = value - } - if value, err := strconv.ParseInt(cloneExtension.SelectElement("timeout").Text(), 10, 32); err == nil { - s.CloneOption.Timeout = int(value) - } - if value, err := strconv.ParseInt(cloneExtension.SelectElement("depth").Text(), 10, 32); err == nil { - s.CloneOption.Depth = int(value) - } - } - } - - if regexTrait := traits.SelectElement( - "jenkins.scm.impl.trait.RegexSCMHeadFilterTrait"); regexTrait != nil { - if regex := regexTrait.SelectElement("regex"); regex != nil { - s.RegexFilter = regex.Text() - } - } - } - return &s -} - -func appendBitbucketServerSourceToEtree(source *etree.Element, s *devopsv1alpha3.BitbucketServerSource) { - source.CreateAttr("class", "com.cloudbees.jenkins.plugins.bitbucket.BitbucketSCMSource") - source.CreateAttr("plugin", "cloudbees-bitbucket-branch-source") - source.CreateElement("id").SetText(s.ScmId) - source.CreateElement("credentialsId").SetText(s.CredentialId) - source.CreateElement("repoOwner").SetText(s.Owner) - source.CreateElement("repository").SetText(s.Repo) - source.CreateElement("serverUrl").SetText(s.ApiUri) - - traits := source.CreateElement("traits") - if s.DiscoverBranches != 0 { - traits.CreateElement("com.cloudbees.jenkins.plugins.bitbucket.BranchDiscoveryTrait>"). - CreateElement("strategyId").SetText(strconv.Itoa(s.DiscoverBranches)) - } - if s.DiscoverPRFromOrigin != 0 { - traits.CreateElement("com.cloudbees.jenkins.plugins.bitbucket.OriginPullRequestDiscoveryTrait"). - CreateElement("strategyId").SetText(strconv.Itoa(s.DiscoverPRFromOrigin)) - } - if s.DiscoverPRFromForks != nil { - forkTrait := traits.CreateElement("com.cloudbees.jenkins.plugins.bitbucket.ForkPullRequestDiscoveryTrait") - forkTrait.CreateElement("strategyId").SetText(strconv.Itoa(s.DiscoverPRFromForks.Strategy)) - trustClass := "com.cloudbees.jenkins.plugins.bitbucket.ForkPullRequestDiscoveryTrait$" - switch s.DiscoverPRFromForks.Trust { - case 1: - trustClass += "TrustEveryone" - case 2: - trustClass += "TrustTeamForks" - case 3: - trustClass += "TrustNobody" - default: - trustClass += "TrustEveryone" - } - forkTrait.CreateElement("trust").CreateAttr("class", trustClass) - } - if s.DiscoverTags { - traits.CreateElement("com.cloudbees.jenkins.plugins.bitbucket.TagDiscoveryTrait") - } - if s.CloneOption != nil { - cloneExtension := traits.CreateElement("jenkins.plugins.git.traits.CloneOptionTrait").CreateElement("extension") - cloneExtension.CreateAttr("class", "hudson.plugins.git.extensions.impl.CloneOption") - cloneExtension.CreateElement("shallow").SetText(strconv.FormatBool(s.CloneOption.Shallow)) - cloneExtension.CreateElement("noTags").SetText(strconv.FormatBool(false)) - cloneExtension.CreateElement("honorRefspec").SetText(strconv.FormatBool(true)) - cloneExtension.CreateElement("reference") - if s.CloneOption.Timeout >= 0 { - cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(s.CloneOption.Timeout)) - } else { - cloneExtension.CreateElement("timeout").SetText(strconv.Itoa(10)) - } - - if s.CloneOption.Depth >= 0 { - cloneExtension.CreateElement("depth").SetText(strconv.Itoa(s.CloneOption.Depth)) - } else { - cloneExtension.CreateElement("depth").SetText(strconv.Itoa(1)) - } - } - if s.RegexFilter != "" { - regexTraits := traits.CreateElement("jenkins.scm.impl.trait.RegexSCMHeadFilterTrait") - regexTraits.CreateAttr("plugin", "scm-api@2.4.0") - regexTraits.CreateElement("regex").SetText(s.RegexFilter) - } - return -} - -func getSvnSourcefromEtree(source *etree.Element) *devopsv1alpha3.SvnSource { - var s devopsv1alpha3.SvnSource - if remote := source.SelectElement("remoteBase"); remote != nil { - s.Remote = remote.Text() - } - - if credentialsId := source.SelectElement("credentialsId"); credentialsId != nil { - s.CredentialId = credentialsId.Text() - } - - if includes := source.SelectElement("includes"); includes != nil { - s.Includes = includes.Text() - } - - if excludes := source.SelectElement("excludes"); excludes != nil { - s.Excludes = excludes.Text() - } - return &s -} - -func appendSvnSourceToEtree(source *etree.Element, s *devopsv1alpha3.SvnSource) { - source.CreateAttr("class", "jenkins.scm.impl.subversion.SubversionSCMSource") - source.CreateAttr("plugin", "subversion") - source.CreateElement("id").SetText(s.ScmId) - if s.CredentialId != "" { - source.CreateElement("credentialsId").SetText(s.CredentialId) - } - if s.Remote != "" { - source.CreateElement("remoteBase").SetText(s.Remote) - } - if s.Includes != "" { - source.CreateElement("includes").SetText(s.Includes) - } - if s.Excludes != "" { - source.CreateElement("excludes").SetText(s.Excludes) - } - return -} - -func getSingleSvnSourceFromEtree(source *etree.Element) *devopsv1alpha3.SingleSvnSource { - var s devopsv1alpha3.SingleSvnSource - if scm := source.SelectElement("scm"); scm != nil { - if locations := scm.SelectElement("locations"); locations != nil { - if moduleLocations := locations.SelectElement("hudson.scm.SubversionSCM_-ModuleLocation"); moduleLocations != nil { - if remote := moduleLocations.SelectElement("remote"); remote != nil { - s.Remote = remote.Text() - } - if credentialId := moduleLocations.SelectElement("credentialsId"); credentialId != nil { - s.CredentialId = credentialId.Text() - } - } - } - } - return &s -} - -func appendSingleSvnSourceToEtree(source *etree.Element, s *devopsv1alpha3.SingleSvnSource) { - - source.CreateAttr("class", "jenkins.scm.impl.SingleSCMSource") - source.CreateAttr("plugin", "scm-api") - source.CreateElement("id").SetText(s.ScmId) - source.CreateElement("name").SetText("master") - - scm := source.CreateElement("scm") - scm.CreateAttr("class", "hudson.scm.SubversionSCM") - scm.CreateAttr("plugin", "subversion") - - location := scm.CreateElement("locations").CreateElement("hudson.scm.SubversionSCM_-ModuleLocation") - if s.Remote != "" { - location.CreateElement("remote").SetText(s.Remote) - } - if s.CredentialId != "" { - location.CreateElement("credentialsId").SetText(s.CredentialId) - } - location.CreateElement("local").SetText(".") - location.CreateElement("depthOption").SetText("infinity") - location.CreateElement("ignoreExternalsOption").SetText("true") - location.CreateElement("cancelProcessOnExternalsFail").SetText("true") - - source.CreateElement("excludedRegions") - source.CreateElement("includedRegions") - source.CreateElement("excludedUsers") - source.CreateElement("excludedRevprop") - source.CreateElement("excludedCommitMessages") - source.CreateElement("workspaceUpdater").CreateAttr("class", "hudson.scm.subversion.UpdateUpdater") - source.CreateElement("ignoreDirPropChanges").SetText("false") - source.CreateElement("filterChangelog").SetText("false") - source.CreateElement("quietOperation").SetText("true") - - return -} - func appendMultiBranchJobTriggerToEtree(properties *etree.Element, s *devopsv1alpha3.MultiBranchJobTrigger) { triggerProperty := properties.CreateElement("org.jenkinsci.plugins.workflow.multibranch.PipelineTriggerProperty") triggerProperty.CreateAttr("plugin", "multibranch-action-triggers") @@ -814,17 +345,17 @@ func createMultiBranchPipelineConfigXml(projectName string, pipeline *devopsv1al switch pipeline.SourceType { case devopsv1alpha3.SourceTypeGit: - appendGitSourceToEtree(source, pipeline.GitSource) + internal.AppendGitSourceToEtree(source, pipeline.GitSource) case devopsv1alpha3.SourceTypeGithub: - appendGithubSourceToEtree(source, pipeline.GitHubSource) + internal.AppendGithubSourceToEtree(source, pipeline.GitHubSource) case devopsv1alpha3.SourceTypeGitlab: internal.AppendGitlabSourceToEtree(source, pipeline.GitlabSource) case devopsv1alpha3.SourceTypeSVN: - appendSvnSourceToEtree(source, pipeline.SvnSource) + internal.AppendSvnSourceToEtree(source, pipeline.SvnSource) case devopsv1alpha3.SourceTypeSingleSVN: - appendSingleSvnSourceToEtree(source, pipeline.SingleSvnSource) + internal.AppendSingleSvnSourceToEtree(source, pipeline.SingleSvnSource) case devopsv1alpha3.SourceTypeBitbucket: - appendBitbucketServerSourceToEtree(source, pipeline.BitbucketServerSource) + internal.AppendBitbucketServerSourceToEtree(source, pipeline.BitbucketServerSource) default: return "", fmt.Errorf("unsupport source type: %s", pipeline.SourceType) @@ -883,10 +414,10 @@ func parseMultiBranchPipelineConfigXml(config string) (*devopsv1alpha3.MultiBran source := branchSource.SelectElement("source") switch source.SelectAttr("class").Value { case "org.jenkinsci.plugins.github_branch_source.GitHubSCMSource": - pipeline.GitHubSource = getGithubSourcefromEtree(source) + pipeline.GitHubSource = internal.GetGithubSourcefromEtree(source) pipeline.SourceType = devopsv1alpha3.SourceTypeGithub case "com.cloudbees.jenkins.plugins.bitbucket.BitbucketSCMSource": - pipeline.BitbucketServerSource = getBitbucketServerSourceFromEtree(source) + pipeline.BitbucketServerSource = internal.GetBitbucketServerSourceFromEtree(source) pipeline.SourceType = devopsv1alpha3.SourceTypeBitbucket case "io.jenkins.plugins.gitlabbranchsource.GitLabSCMSource": pipeline.GitlabSource = internal.GetGitlabSourceFromEtree(source) @@ -894,15 +425,15 @@ func parseMultiBranchPipelineConfigXml(config string) (*devopsv1alpha3.MultiBran case "jenkins.plugins.git.GitSCMSource": pipeline.SourceType = devopsv1alpha3.SourceTypeGit - pipeline.GitSource = getGitSourcefromEtree(source) + pipeline.GitSource = internal.GetGitSourcefromEtree(source) case "jenkins.scm.impl.SingleSCMSource": pipeline.SourceType = devopsv1alpha3.SourceTypeSingleSVN - pipeline.SingleSvnSource = getSingleSvnSourceFromEtree(source) + pipeline.SingleSvnSource = internal.GetSingleSvnSourceFromEtree(source) case "jenkins.scm.impl.subversion.SubversionSCMSource": pipeline.SourceType = devopsv1alpha3.SourceTypeSVN - pipeline.SvnSource = getSvnSourcefromEtree(source) + pipeline.SvnSource = internal.GetSvnSourcefromEtree(source) } } }