mirror of
https://github.com/jenkinsci/kubernetes-operator.git
synced 2026-10-21 04:23:25 +02:00
reorganise directories for better readbility
This commit is contained in:
jkhelil
@@ -0,0 +1,2 @@
|
||||
// Package client contains client for Jenkins API
|
||||
package client
|
||||
@@ -0,0 +1,231 @@
|
||||
package client
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/cookiejar"
|
||||
"regexp"
|
||||
"strings"
|
||||
|
||||
"github.com/bndr/gojenkins"
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
||||
var (
|
||||
errorNotFound = errors.New("404")
|
||||
regex = regexp.MustCompile("(<application-desc main-class=\"hudson.remoting.jnlp.Main\"><argument>)(?P<secret>[a-z0-9]*)")
|
||||
)
|
||||
|
||||
// Jenkins defines Jenkins API.
|
||||
type Jenkins interface {
|
||||
GenerateToken(userName, tokenName string) (*UserToken, error)
|
||||
Info() (*gojenkins.ExecutorResponse, error)
|
||||
SafeRestart() error
|
||||
CreateNode(name string, numExecutors int, description string, remoteFS string, label string, options ...interface{}) (*gojenkins.Node, error)
|
||||
DeleteNode(name string) (bool, error)
|
||||
CreateFolder(name string, parents ...string) (*gojenkins.Folder, error)
|
||||
CreateJobInFolder(config string, jobName string, parentIDs ...string) (*gojenkins.Job, error)
|
||||
CreateJob(config string, options ...interface{}) (*gojenkins.Job, error)
|
||||
CreateOrUpdateJob(config, jobName string) (*gojenkins.Job, bool, error)
|
||||
RenameJob(job string, name string) *gojenkins.Job
|
||||
CopyJob(copyFrom string, newName string) (*gojenkins.Job, error)
|
||||
DeleteJob(name string) (bool, error)
|
||||
BuildJob(name string, options ...interface{}) (int64, error)
|
||||
GetNode(name string) (*gojenkins.Node, error)
|
||||
GetLabel(name string) (*gojenkins.Label, error)
|
||||
GetBuild(jobName string, number int64) (*gojenkins.Build, error)
|
||||
GetJob(id string, parentIDs ...string) (*gojenkins.Job, error)
|
||||
GetSubJob(parentID string, childID string) (*gojenkins.Job, error)
|
||||
GetFolder(id string, parents ...string) (*gojenkins.Folder, error)
|
||||
GetAllNodes() ([]*gojenkins.Node, error)
|
||||
GetAllBuildIds(job string) ([]gojenkins.JobBuild, error)
|
||||
GetAllJobNames() ([]gojenkins.InnerJob, error)
|
||||
GetAllJobs() ([]*gojenkins.Job, error)
|
||||
GetQueue() (*gojenkins.Queue, error)
|
||||
GetQueueUrl() string
|
||||
GetQueueItem(id int64) (*gojenkins.Task, error)
|
||||
GetArtifactData(id string) (*gojenkins.FingerPrintResponse, error)
|
||||
GetPlugins(depth int) (*gojenkins.Plugins, error)
|
||||
UninstallPlugin(name string) error
|
||||
HasPlugin(name string) (*gojenkins.Plugin, error)
|
||||
InstallPlugin(name string, version string) error
|
||||
ValidateFingerPrint(id string) (bool, error)
|
||||
GetView(name string) (*gojenkins.View, error)
|
||||
GetAllViews() ([]*gojenkins.View, error)
|
||||
CreateView(name string, viewType string) (*gojenkins.View, error)
|
||||
Poll() (int, error)
|
||||
ExecuteScript(groovyScript string) (logs string, err error)
|
||||
GetNodeSecret(name string) (string, error)
|
||||
}
|
||||
|
||||
type jenkins struct {
|
||||
gojenkins.Jenkins
|
||||
}
|
||||
|
||||
// JenkinsAPIConnectionSettings is struct that handle information about Jenkins API connection.
|
||||
type JenkinsAPIConnectionSettings struct {
|
||||
Hostname string
|
||||
Port int
|
||||
UseNodePort bool
|
||||
}
|
||||
|
||||
type setBearerToken struct {
|
||||
rt http.RoundTripper
|
||||
token string
|
||||
}
|
||||
|
||||
func (t *setBearerToken) transport() http.RoundTripper {
|
||||
if t.rt != nil {
|
||||
return t.rt
|
||||
}
|
||||
return http.DefaultTransport
|
||||
}
|
||||
|
||||
func (t *setBearerToken) RoundTrip(r *http.Request) (*http.Response, error) {
|
||||
r.Header.Set("Authorization", fmt.Sprintf("Bearer %s", t.token))
|
||||
return t.transport().RoundTrip(r)
|
||||
}
|
||||
|
||||
// CreateOrUpdateJob creates or updates a job from config.
|
||||
func (jenkins *jenkins) CreateOrUpdateJob(config, jobName string) (job *gojenkins.Job, created bool, err error) {
|
||||
// create or update
|
||||
job, err = jenkins.GetJob(jobName)
|
||||
if isNotFoundError(err) {
|
||||
job, err = jenkins.CreateJob(config, jobName)
|
||||
created = true
|
||||
return job, true, errors.WithStack(err)
|
||||
} else if err != nil {
|
||||
return job, false, errors.WithStack(err)
|
||||
}
|
||||
|
||||
err = job.UpdateConfig(config)
|
||||
return job, false, errors.WithStack(err)
|
||||
}
|
||||
|
||||
// BuildJenkinsAPIUrl returns Jenkins API URL.
|
||||
func (j JenkinsAPIConnectionSettings) BuildJenkinsAPIUrl(serviceName string, serviceNamespace string, servicePort int32, serviceNodePort int32) string {
|
||||
if j.Hostname == "" && j.Port == 0 {
|
||||
return fmt.Sprintf("http://%s.%s:%d", serviceName, serviceNamespace, servicePort)
|
||||
}
|
||||
|
||||
if j.Hostname != "" && j.UseNodePort {
|
||||
return fmt.Sprintf("http://%s:%d", j.Hostname, serviceNodePort)
|
||||
}
|
||||
|
||||
return fmt.Sprintf("http://%s:%d", j.Hostname, j.Port)
|
||||
}
|
||||
|
||||
// Validate validates jenkins API connection settings.
|
||||
func (j JenkinsAPIConnectionSettings) Validate() error {
|
||||
if j.Port > 0 && j.UseNodePort {
|
||||
return errors.New("can't use service port and nodePort both. Please use port or nodePort")
|
||||
}
|
||||
|
||||
if j.Port < 0 {
|
||||
return errors.New("service port cannot be lower than 0")
|
||||
}
|
||||
|
||||
if (j.Hostname == "" && j.Port > 0) || (j.Hostname == "" && j.UseNodePort) {
|
||||
return errors.New("empty hostname is now allowed. Please provide hostname")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// NewUserAndPasswordAuthorization creates Jenkins API client with user and password authorization.
|
||||
func NewUserAndPasswordAuthorization(url, userName, passwordOrToken string) (Jenkins, error) {
|
||||
return newClient(url, userName, passwordOrToken)
|
||||
}
|
||||
|
||||
// NewBearerTokenAuthorization creates Jenkins API client with bearer token authorization.
|
||||
func NewBearerTokenAuthorization(url, token string) (Jenkins, error) {
|
||||
return newClient(url, "", token)
|
||||
}
|
||||
|
||||
func newClient(url, userName, passwordOrToken string) (Jenkins, error) {
|
||||
if strings.HasSuffix(url, "/") {
|
||||
url = url[:len(url)-1]
|
||||
}
|
||||
|
||||
jenkinsClient := &jenkins{}
|
||||
jenkinsClient.Server = url
|
||||
|
||||
var basicAuth *gojenkins.BasicAuth
|
||||
jar, err := cookiejar.New(nil)
|
||||
if err != nil {
|
||||
return nil, errors.Wrap(err, "couldn't create a cookie jar")
|
||||
}
|
||||
|
||||
httpClient := &http.Client{Jar: jar}
|
||||
|
||||
if len(userName) > 0 && len(passwordOrToken) > 0 {
|
||||
basicAuth = &gojenkins.BasicAuth{Username: userName, Password: passwordOrToken}
|
||||
} else {
|
||||
httpClient.Transport = &setBearerToken{token: passwordOrToken, rt: httpClient.Transport}
|
||||
}
|
||||
|
||||
jenkinsClient.Requester = &gojenkins.Requester{
|
||||
Base: url,
|
||||
SslVerify: true,
|
||||
Client: httpClient,
|
||||
BasicAuth: basicAuth,
|
||||
}
|
||||
if _, err := jenkinsClient.Init(); err != nil {
|
||||
return nil, errors.Wrap(err, "couldn't init Jenkins API client")
|
||||
}
|
||||
|
||||
status, err := jenkinsClient.Poll()
|
||||
if err != nil {
|
||||
return nil, errors.Wrap(err, "couldn't poll data from Jenkins API")
|
||||
}
|
||||
if status != http.StatusOK {
|
||||
return nil, errors.Errorf("couldn't poll data from Jenkins API, invalid status code returned: %d", status)
|
||||
}
|
||||
|
||||
return jenkinsClient, nil
|
||||
}
|
||||
|
||||
func isNotFoundError(err error) bool {
|
||||
if err != nil {
|
||||
return err.Error() == errorNotFound.Error()
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (jenkins *jenkins) GetNodeSecret(name string) (string, error) {
|
||||
var content string
|
||||
r, err := jenkins.Requester.GetXML(fmt.Sprintf("/computer/%s/slave-agent.jnlp", name), &content, nil)
|
||||
if err != nil {
|
||||
return "", errors.WithStack(err)
|
||||
}
|
||||
defer r.Body.Close()
|
||||
|
||||
match := regex.FindStringSubmatch(content)
|
||||
if match == nil {
|
||||
return "", errors.New("Node secret cannot be parsed")
|
||||
}
|
||||
|
||||
result := make(map[string]string)
|
||||
|
||||
for i, name := range regex.SubexpNames() {
|
||||
if i != 0 && name != "" {
|
||||
result[name] = match[i]
|
||||
}
|
||||
}
|
||||
|
||||
return result["secret"], nil
|
||||
}
|
||||
|
||||
// Returns the list of all plugins installed on the Jenkins server.
|
||||
// You can supply depth parameter, to limit how much data is returned.
|
||||
func (jenkins *jenkins) GetPlugins(depth int) (*gojenkins.Plugins, error) {
|
||||
p := gojenkins.Plugins{Jenkins: &jenkins.Jenkins, Raw: new(gojenkins.PluginResponse), Base: "/pluginManager", Depth: depth}
|
||||
statusCode, err := p.Poll()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if statusCode != http.StatusOK {
|
||||
return nil, fmt.Errorf("invalid status code returned: %d", statusCode)
|
||||
}
|
||||
return &p, nil
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package client
|
||||
|
||||
import (
|
||||
"net/url"
|
||||
|
||||
"github.com/bndr/gojenkins"
|
||||
)
|
||||
|
||||
func (jenkins *jenkins) GetBuild(jobName string, number int64) (*gojenkins.Build, error) {
|
||||
job, err := jenkins.GetJob(jobName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// https://github.com/bndr/gojenkins/issues/176
|
||||
// workaround begin
|
||||
jobURL, err := url.Parse(job.Raw.URL)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
job.Raw.URL = jobURL.RequestURI()
|
||||
// workaround end
|
||||
|
||||
build, err := job.GetBuild(number)
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return build, nil
|
||||
}
|
||||
@@ -0,0 +1,634 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: pkg/controller/jenkins/client/jenkins.go
|
||||
|
||||
// Package mock_client is a generated GoMock package.
|
||||
package client
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
|
||||
"github.com/bndr/gojenkins"
|
||||
"github.com/golang/mock/gomock"
|
||||
)
|
||||
|
||||
// MockJenkins is a mock of Jenkins interface
|
||||
type MockJenkins struct {
|
||||
ctrl *gomock.Controller
|
||||
recorder *MockJenkinsMockRecorder
|
||||
}
|
||||
|
||||
func (m *MockJenkins) GetNodeSecret(name string) (string, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetNodeSecret", name)
|
||||
ret0, _ := ret[0].(string)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
func (mr *MockJenkinsMockRecorder) GetNodeSecret(name string) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeSecret", reflect.TypeOf((*MockJenkins)(nil).GetNodeSecret), name)
|
||||
}
|
||||
|
||||
// MockJenkinsMockRecorder is the mock recorder for MockJenkins
|
||||
type MockJenkinsMockRecorder struct {
|
||||
mock *MockJenkins
|
||||
}
|
||||
|
||||
// NewMockJenkins creates a new mock instance
|
||||
func NewMockJenkins(ctrl *gomock.Controller) *MockJenkins {
|
||||
mock := &MockJenkins{ctrl: ctrl}
|
||||
mock.recorder = &MockJenkinsMockRecorder{mock}
|
||||
return mock
|
||||
}
|
||||
|
||||
// EXPECT returns an object that allows the caller to indicate expected use
|
||||
func (m *MockJenkins) EXPECT() *MockJenkinsMockRecorder {
|
||||
return m.recorder
|
||||
}
|
||||
|
||||
// GenerateToken mocks base method
|
||||
func (m *MockJenkins) GenerateToken(userName, tokenName string) (*UserToken, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GenerateToken", userName, tokenName)
|
||||
ret0, _ := ret[0].(*UserToken)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GenerateToken indicates an expected call of GenerateToken
|
||||
func (mr *MockJenkinsMockRecorder) GenerateToken(userName, tokenName interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateToken", reflect.TypeOf((*MockJenkins)(nil).GenerateToken), userName, tokenName)
|
||||
}
|
||||
|
||||
// Info mocks base method
|
||||
func (m *MockJenkins) Info() (*gojenkins.ExecutorResponse, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "Info")
|
||||
ret0, _ := ret[0].(*gojenkins.ExecutorResponse)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// Info indicates an expected call of Info
|
||||
func (mr *MockJenkinsMockRecorder) Info() *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockJenkins)(nil).Info))
|
||||
}
|
||||
|
||||
// SafeRestart mocks base method
|
||||
func (m *MockJenkins) SafeRestart() error {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "SafeRestart")
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// SafeRestart indicates an expected call of SafeRestart
|
||||
func (mr *MockJenkinsMockRecorder) SafeRestart() *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SafeRestart", reflect.TypeOf((*MockJenkins)(nil).SafeRestart))
|
||||
}
|
||||
|
||||
// CreateNode mocks base method
|
||||
func (m *MockJenkins) CreateNode(name string, numExecutors int, description, remoteFS, label string, options ...interface{}) (*gojenkins.Node, error) {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []interface{}{name, numExecutors, description, remoteFS, label}
|
||||
for _, a := range options {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "CreateNode", varargs...)
|
||||
ret0, _ := ret[0].(*gojenkins.Node)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// CreateNode indicates an expected call of CreateNode
|
||||
func (mr *MockJenkinsMockRecorder) CreateNode(name, numExecutors, description, remoteFS, label interface{}, options ...interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]interface{}{name, numExecutors, description, remoteFS, label}, options...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNode", reflect.TypeOf((*MockJenkins)(nil).CreateNode), varargs...)
|
||||
}
|
||||
|
||||
// DeleteNode mocks base method
|
||||
func (m *MockJenkins) DeleteNode(name string) (bool, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "DeleteNode", name)
|
||||
ret0, _ := ret[0].(bool)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// DeleteNode indicates an expected call of DeleteNode
|
||||
func (mr *MockJenkinsMockRecorder) DeleteNode(name interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNode", reflect.TypeOf((*MockJenkins)(nil).DeleteNode), name)
|
||||
}
|
||||
|
||||
// CreateFolder mocks base method
|
||||
func (m *MockJenkins) CreateFolder(name string, parents ...string) (*gojenkins.Folder, error) {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []interface{}{name}
|
||||
for _, a := range parents {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "CreateFolder", varargs...)
|
||||
ret0, _ := ret[0].(*gojenkins.Folder)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// CreateFolder indicates an expected call of CreateFolder
|
||||
func (mr *MockJenkinsMockRecorder) CreateFolder(name interface{}, parents ...interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]interface{}{name}, parents...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFolder", reflect.TypeOf((*MockJenkins)(nil).CreateFolder), varargs...)
|
||||
}
|
||||
|
||||
// CreateJobInFolder mocks base method
|
||||
func (m *MockJenkins) CreateJobInFolder(config, jobName string, parentIDs ...string) (*gojenkins.Job, error) {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []interface{}{config, jobName}
|
||||
for _, a := range parentIDs {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "CreateJobInFolder", varargs...)
|
||||
ret0, _ := ret[0].(*gojenkins.Job)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// CreateJobInFolder indicates an expected call of CreateJobInFolder
|
||||
func (mr *MockJenkinsMockRecorder) CreateJobInFolder(config, jobName interface{}, parentIDs ...interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]interface{}{config, jobName}, parentIDs...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateJobInFolder", reflect.TypeOf((*MockJenkins)(nil).CreateJobInFolder), varargs...)
|
||||
}
|
||||
|
||||
// CreateJob mocks base method
|
||||
func (m *MockJenkins) CreateJob(config string, options ...interface{}) (*gojenkins.Job, error) {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []interface{}{config}
|
||||
for _, a := range options {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "CreateJob", varargs...)
|
||||
ret0, _ := ret[0].(*gojenkins.Job)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// CreateJob indicates an expected call of CreateJob
|
||||
func (mr *MockJenkinsMockRecorder) CreateJob(config interface{}, options ...interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]interface{}{config}, options...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateJob", reflect.TypeOf((*MockJenkins)(nil).CreateJob), varargs...)
|
||||
}
|
||||
|
||||
// CreateOrUpdateJob mocks base method
|
||||
func (m *MockJenkins) CreateOrUpdateJob(config, jobName string) (*gojenkins.Job, bool, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "CreateOrUpdateJob", config, jobName)
|
||||
ret0, _ := ret[0].(*gojenkins.Job)
|
||||
ret1, _ := ret[1].(bool)
|
||||
ret2, _ := ret[2].(error)
|
||||
return ret0, ret1, ret2
|
||||
}
|
||||
|
||||
// CreateOrUpdateJob indicates an expected call of CreateOrUpdateJob
|
||||
func (mr *MockJenkinsMockRecorder) CreateOrUpdateJob(config, jobName interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateJob", reflect.TypeOf((*MockJenkins)(nil).CreateOrUpdateJob), config, jobName)
|
||||
}
|
||||
|
||||
// RenameJob mocks base method
|
||||
func (m *MockJenkins) RenameJob(job, name string) *gojenkins.Job {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "RenameJob", job, name)
|
||||
ret0, _ := ret[0].(*gojenkins.Job)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// RenameJob indicates an expected call of RenameJob
|
||||
func (mr *MockJenkinsMockRecorder) RenameJob(job, name interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameJob", reflect.TypeOf((*MockJenkins)(nil).RenameJob), job, name)
|
||||
}
|
||||
|
||||
// CopyJob mocks base method
|
||||
func (m *MockJenkins) CopyJob(copyFrom, newName string) (*gojenkins.Job, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "CopyJob", copyFrom, newName)
|
||||
ret0, _ := ret[0].(*gojenkins.Job)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// CopyJob indicates an expected call of CopyJob
|
||||
func (mr *MockJenkinsMockRecorder) CopyJob(copyFrom, newName interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyJob", reflect.TypeOf((*MockJenkins)(nil).CopyJob), copyFrom, newName)
|
||||
}
|
||||
|
||||
// DeleteJob mocks base method
|
||||
func (m *MockJenkins) DeleteJob(name string) (bool, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "DeleteJob", name)
|
||||
ret0, _ := ret[0].(bool)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// DeleteJob indicates an expected call of DeleteJob
|
||||
func (mr *MockJenkinsMockRecorder) DeleteJob(name interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteJob", reflect.TypeOf((*MockJenkins)(nil).DeleteJob), name)
|
||||
}
|
||||
|
||||
// BuildJob mocks base method
|
||||
func (m *MockJenkins) BuildJob(name string, options ...interface{}) (int64, error) {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []interface{}{name}
|
||||
for _, a := range options {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "BuildJob", varargs...)
|
||||
ret0, _ := ret[0].(int64)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// BuildJob indicates an expected call of BuildJob
|
||||
func (mr *MockJenkinsMockRecorder) BuildJob(name interface{}, options ...interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]interface{}{name}, options...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildJob", reflect.TypeOf((*MockJenkins)(nil).BuildJob), varargs...)
|
||||
}
|
||||
|
||||
// GetNode mocks base method
|
||||
func (m *MockJenkins) GetNode(name string) (*gojenkins.Node, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetNode", name)
|
||||
ret0, _ := ret[0].(*gojenkins.Node)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetNode indicates an expected call of GetNode
|
||||
func (mr *MockJenkinsMockRecorder) GetNode(name interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNode", reflect.TypeOf((*MockJenkins)(nil).GetNode), name)
|
||||
}
|
||||
|
||||
// GetLabel mocks base method
|
||||
func (m *MockJenkins) GetLabel(name string) (*gojenkins.Label, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetLabel", name)
|
||||
ret0, _ := ret[0].(*gojenkins.Label)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetLabel indicates an expected call of GetLabel
|
||||
func (mr *MockJenkinsMockRecorder) GetLabel(name interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLabel", reflect.TypeOf((*MockJenkins)(nil).GetLabel), name)
|
||||
}
|
||||
|
||||
// GetBuild mocks base method
|
||||
func (m *MockJenkins) GetBuild(jobName string, number int64) (*gojenkins.Build, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetBuild", jobName, number)
|
||||
ret0, _ := ret[0].(*gojenkins.Build)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetBuild indicates an expected call of GetBuild
|
||||
func (mr *MockJenkinsMockRecorder) GetBuild(jobName, number interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuild", reflect.TypeOf((*MockJenkins)(nil).GetBuild), jobName, number)
|
||||
}
|
||||
|
||||
// GetJob mocks base method
|
||||
func (m *MockJenkins) GetJob(id string, parentIDs ...string) (*gojenkins.Job, error) {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []interface{}{id}
|
||||
for _, a := range parentIDs {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "GetJob", varargs...)
|
||||
ret0, _ := ret[0].(*gojenkins.Job)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetJob indicates an expected call of GetJob
|
||||
func (mr *MockJenkinsMockRecorder) GetJob(id interface{}, parentIDs ...interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]interface{}{id}, parentIDs...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJob", reflect.TypeOf((*MockJenkins)(nil).GetJob), varargs...)
|
||||
}
|
||||
|
||||
// GetSubJob mocks base method
|
||||
func (m *MockJenkins) GetSubJob(parentID, childID string) (*gojenkins.Job, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetSubJob", parentID, childID)
|
||||
ret0, _ := ret[0].(*gojenkins.Job)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetSubJob indicates an expected call of GetSubJob
|
||||
func (mr *MockJenkinsMockRecorder) GetSubJob(parentID, childID interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubJob", reflect.TypeOf((*MockJenkins)(nil).GetSubJob), parentID, childID)
|
||||
}
|
||||
|
||||
// GetFolder mocks base method
|
||||
func (m *MockJenkins) GetFolder(id string, parents ...string) (*gojenkins.Folder, error) {
|
||||
m.ctrl.T.Helper()
|
||||
varargs := []interface{}{id}
|
||||
for _, a := range parents {
|
||||
varargs = append(varargs, a)
|
||||
}
|
||||
ret := m.ctrl.Call(m, "GetFolder", varargs...)
|
||||
ret0, _ := ret[0].(*gojenkins.Folder)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetFolder indicates an expected call of GetFolder
|
||||
func (mr *MockJenkinsMockRecorder) GetFolder(id interface{}, parents ...interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
varargs := append([]interface{}{id}, parents...)
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFolder", reflect.TypeOf((*MockJenkins)(nil).GetFolder), varargs...)
|
||||
}
|
||||
|
||||
// GetAllNodes mocks base method
|
||||
func (m *MockJenkins) GetAllNodes() ([]*gojenkins.Node, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetAllNodes")
|
||||
ret0, _ := ret[0].([]*gojenkins.Node)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetAllNodes indicates an expected call of GetAllNodes
|
||||
func (mr *MockJenkinsMockRecorder) GetAllNodes() *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllNodes", reflect.TypeOf((*MockJenkins)(nil).GetAllNodes))
|
||||
}
|
||||
|
||||
// GetAllBuildIds mocks base method
|
||||
func (m *MockJenkins) GetAllBuildIds(job string) ([]gojenkins.JobBuild, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetAllBuildIds", job)
|
||||
ret0, _ := ret[0].([]gojenkins.JobBuild)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetAllBuildIds indicates an expected call of GetAllBuildIds
|
||||
func (mr *MockJenkinsMockRecorder) GetAllBuildIds(job interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBuildIds", reflect.TypeOf((*MockJenkins)(nil).GetAllBuildIds), job)
|
||||
}
|
||||
|
||||
// GetAllJobNames mocks base method
|
||||
func (m *MockJenkins) GetAllJobNames() ([]gojenkins.InnerJob, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetAllJobNames")
|
||||
ret0, _ := ret[0].([]gojenkins.InnerJob)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetAllJobNames indicates an expected call of GetAllJobNames
|
||||
func (mr *MockJenkinsMockRecorder) GetAllJobNames() *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllJobNames", reflect.TypeOf((*MockJenkins)(nil).GetAllJobNames))
|
||||
}
|
||||
|
||||
// GetAllJobs mocks base method
|
||||
func (m *MockJenkins) GetAllJobs() ([]*gojenkins.Job, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetAllJobs")
|
||||
ret0, _ := ret[0].([]*gojenkins.Job)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetAllJobs indicates an expected call of GetAllJobs
|
||||
func (mr *MockJenkinsMockRecorder) GetAllJobs() *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllJobs", reflect.TypeOf((*MockJenkins)(nil).GetAllJobs))
|
||||
}
|
||||
|
||||
// GetQueue mocks base method
|
||||
func (m *MockJenkins) GetQueue() (*gojenkins.Queue, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetQueue")
|
||||
ret0, _ := ret[0].(*gojenkins.Queue)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetQueue indicates an expected call of GetQueue
|
||||
func (mr *MockJenkinsMockRecorder) GetQueue() *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueue", reflect.TypeOf((*MockJenkins)(nil).GetQueue))
|
||||
}
|
||||
|
||||
// GetQueueUrl mocks base method
|
||||
func (m *MockJenkins) GetQueueUrl() string {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetQueueUrl")
|
||||
ret0, _ := ret[0].(string)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// GetQueueUrl indicates an expected call of GetQueueUrl
|
||||
func (mr *MockJenkinsMockRecorder) GetQueueUrl() *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrl", reflect.TypeOf((*MockJenkins)(nil).GetQueueUrl))
|
||||
}
|
||||
|
||||
// GetQueueItem mocks base method
|
||||
func (m *MockJenkins) GetQueueItem(id int64) (*gojenkins.Task, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetQueueItem", id)
|
||||
ret0, _ := ret[0].(*gojenkins.Task)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetQueueItem indicates an expected call of GetQueueItem
|
||||
func (mr *MockJenkinsMockRecorder) GetQueueItem(id interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueItem", reflect.TypeOf((*MockJenkins)(nil).GetQueueItem), id)
|
||||
}
|
||||
|
||||
// GetArtifactData mocks base method
|
||||
func (m *MockJenkins) GetArtifactData(id string) (*gojenkins.FingerPrintResponse, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetArtifactData", id)
|
||||
ret0, _ := ret[0].(*gojenkins.FingerPrintResponse)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetArtifactData indicates an expected call of GetArtifactData
|
||||
func (mr *MockJenkinsMockRecorder) GetArtifactData(id interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifactData", reflect.TypeOf((*MockJenkins)(nil).GetArtifactData), id)
|
||||
}
|
||||
|
||||
// GetPlugins mocks base method
|
||||
func (m *MockJenkins) GetPlugins(depth int) (*gojenkins.Plugins, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetPlugins", depth)
|
||||
ret0, _ := ret[0].(*gojenkins.Plugins)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetPlugins indicates an expected call of GetPlugins
|
||||
func (mr *MockJenkinsMockRecorder) GetPlugins(depth interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlugins", reflect.TypeOf((*MockJenkins)(nil).GetPlugins), depth)
|
||||
}
|
||||
|
||||
// UninstallPlugin mocks base method
|
||||
func (m *MockJenkins) UninstallPlugin(name string) error {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "UninstallPlugin", name)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// UninstallPlugin indicates an expected call of UninstallPlugin
|
||||
func (mr *MockJenkinsMockRecorder) UninstallPlugin(name interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UninstallPlugin", reflect.TypeOf((*MockJenkins)(nil).UninstallPlugin), name)
|
||||
}
|
||||
|
||||
// HasPlugin mocks base method
|
||||
func (m *MockJenkins) HasPlugin(name string) (*gojenkins.Plugin, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "HasPlugin", name)
|
||||
ret0, _ := ret[0].(*gojenkins.Plugin)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// HasPlugin indicates an expected call of HasPlugin
|
||||
func (mr *MockJenkinsMockRecorder) HasPlugin(name interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPlugin", reflect.TypeOf((*MockJenkins)(nil).HasPlugin), name)
|
||||
}
|
||||
|
||||
// InstallPlugin mocks base method
|
||||
func (m *MockJenkins) InstallPlugin(name, version string) error {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "InstallPlugin", name, version)
|
||||
ret0, _ := ret[0].(error)
|
||||
return ret0
|
||||
}
|
||||
|
||||
// InstallPlugin indicates an expected call of InstallPlugin
|
||||
func (mr *MockJenkinsMockRecorder) InstallPlugin(name, version interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallPlugin", reflect.TypeOf((*MockJenkins)(nil).InstallPlugin), name, version)
|
||||
}
|
||||
|
||||
// ValidateFingerPrint mocks base method
|
||||
func (m *MockJenkins) ValidateFingerPrint(id string) (bool, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "ValidateFingerPrint", id)
|
||||
ret0, _ := ret[0].(bool)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ValidateFingerPrint indicates an expected call of ValidateFingerPrint
|
||||
func (mr *MockJenkinsMockRecorder) ValidateFingerPrint(id interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateFingerPrint", reflect.TypeOf((*MockJenkins)(nil).ValidateFingerPrint), id)
|
||||
}
|
||||
|
||||
// GetView mocks base method
|
||||
func (m *MockJenkins) GetView(name string) (*gojenkins.View, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetView", name)
|
||||
ret0, _ := ret[0].(*gojenkins.View)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetView indicates an expected call of GetView
|
||||
func (mr *MockJenkinsMockRecorder) GetView(name interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetView", reflect.TypeOf((*MockJenkins)(nil).GetView), name)
|
||||
}
|
||||
|
||||
// GetAllViews mocks base method
|
||||
func (m *MockJenkins) GetAllViews() ([]*gojenkins.View, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "GetAllViews")
|
||||
ret0, _ := ret[0].([]*gojenkins.View)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// GetAllViews indicates an expected call of GetAllViews
|
||||
func (mr *MockJenkinsMockRecorder) GetAllViews() *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllViews", reflect.TypeOf((*MockJenkins)(nil).GetAllViews))
|
||||
}
|
||||
|
||||
// CreateView mocks base method
|
||||
func (m *MockJenkins) CreateView(name, viewType string) (*gojenkins.View, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "CreateView", name, viewType)
|
||||
ret0, _ := ret[0].(*gojenkins.View)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// CreateView indicates an expected call of CreateView
|
||||
func (mr *MockJenkinsMockRecorder) CreateView(name, viewType interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateView", reflect.TypeOf((*MockJenkins)(nil).CreateView), name, viewType)
|
||||
}
|
||||
|
||||
// Poll mocks base method
|
||||
func (m *MockJenkins) Poll() (int, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "Poll")
|
||||
ret0, _ := ret[0].(int)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// Poll indicates an expected call of Poll
|
||||
func (mr *MockJenkinsMockRecorder) Poll() *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Poll", reflect.TypeOf((*MockJenkins)(nil).Poll))
|
||||
}
|
||||
|
||||
// ExecuteScript mocks base method
|
||||
func (m *MockJenkins) ExecuteScript(groovyScript string) (string, error) {
|
||||
m.ctrl.T.Helper()
|
||||
ret := m.ctrl.Call(m, "ExecuteScript", groovyScript)
|
||||
ret0, _ := ret[0].(string)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// ExecuteScript indicates an expected call of ExecuteScript
|
||||
func (mr *MockJenkinsMockRecorder) ExecuteScript(groovyScript interface{}) *gomock.Call {
|
||||
mr.mock.ctrl.T.Helper()
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScript", reflect.TypeOf((*MockJenkins)(nil).ExecuteScript), groovyScript)
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package client
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/bndr/gojenkins"
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
||||
// GroovyScriptExecutionFailed is custom error type which indicates passed groovy script is invalid
|
||||
type GroovyScriptExecutionFailed struct {
|
||||
ConfigurationType string
|
||||
Source string
|
||||
Name string
|
||||
Logs string
|
||||
}
|
||||
|
||||
func (e GroovyScriptExecutionFailed) Error() string {
|
||||
return "script execution failed"
|
||||
}
|
||||
|
||||
func (jenkins *jenkins) ExecuteScript(script string) (string, error) {
|
||||
now := time.Now().Unix()
|
||||
verifier := fmt.Sprintf("verifier-%d", now)
|
||||
return jenkins.executeScript(script, verifier)
|
||||
}
|
||||
|
||||
func (jenkins *jenkins) executeScript(script string, verifier string) (string, error) {
|
||||
output := ""
|
||||
fullScript := fmt.Sprintf("%s\nprint println('%s')", script, verifier)
|
||||
|
||||
data := url.Values{}
|
||||
data.Set("script", fullScript)
|
||||
|
||||
ar := gojenkins.NewAPIRequest("POST", "/scriptText", bytes.NewBufferString(data.Encode()))
|
||||
if err := jenkins.Requester.SetCrumb(ar); err != nil {
|
||||
return output, err
|
||||
}
|
||||
ar.SetHeader("Content-Type", "application/x-www-form-urlencoded")
|
||||
ar.Suffix = ""
|
||||
|
||||
r, err := jenkins.Requester.Do(ar, &output, nil)
|
||||
if err != nil {
|
||||
return "", errors.Wrapf(err, "couldn't execute groovy script, logs '%s'", output)
|
||||
}
|
||||
defer r.Body.Close()
|
||||
|
||||
if r.StatusCode != http.StatusOK {
|
||||
return output, errors.Errorf("invalid status code '%d', logs '%s'", r.StatusCode, output)
|
||||
}
|
||||
|
||||
if !strings.Contains(output, verifier) {
|
||||
return output, &GroovyScriptExecutionFailed{}
|
||||
}
|
||||
|
||||
return output, nil
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
package client
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/bndr/gojenkins"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
const script = "some groovy code"
|
||||
|
||||
func Test_ExecuteScript(t *testing.T) {
|
||||
verifier := "verifier-text"
|
||||
t.Run("logs have verifier text", func(t *testing.T) {
|
||||
ts := httptest.NewTLSServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
|
||||
if strings.Contains(request.URL.Path, "/scriptText") {
|
||||
_, _ = fmt.Fprint(responseWriter, "some output\n"+verifier)
|
||||
return
|
||||
}
|
||||
responseWriter.WriteHeader(http.StatusInternalServerError)
|
||||
}))
|
||||
defer ts.Close()
|
||||
|
||||
client := ts.Client()
|
||||
|
||||
jenkinsClient := &jenkins{}
|
||||
jenkinsClient.Server = ts.URL
|
||||
jenkinsClient.Requester = &gojenkins.Requester{
|
||||
Base: ts.URL,
|
||||
SslVerify: true,
|
||||
Client: client,
|
||||
BasicAuth: &gojenkins.BasicAuth{Username: "unused", Password: "unused"},
|
||||
}
|
||||
|
||||
logs, err := jenkinsClient.executeScript(script, verifier)
|
||||
assert.NoError(t, err, logs)
|
||||
})
|
||||
t.Run("logs don't have verifier text", func(t *testing.T) {
|
||||
response := "some exception stack trace without verifier"
|
||||
ts := httptest.NewTLSServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
|
||||
if strings.Contains(request.URL.Path, "/scriptText") {
|
||||
_, _ = fmt.Fprint(responseWriter, response)
|
||||
return
|
||||
}
|
||||
responseWriter.WriteHeader(http.StatusInternalServerError)
|
||||
}))
|
||||
defer ts.Close()
|
||||
|
||||
client := ts.Client()
|
||||
|
||||
jenkinsClient := &jenkins{}
|
||||
jenkinsClient.Server = ts.URL
|
||||
jenkinsClient.Requester = &gojenkins.Requester{
|
||||
Base: ts.URL,
|
||||
SslVerify: true,
|
||||
Client: client,
|
||||
BasicAuth: &gojenkins.BasicAuth{Username: "unused", Password: "unused"},
|
||||
}
|
||||
|
||||
logs, err := jenkinsClient.executeScript(script, verifier)
|
||||
assert.EqualError(t, err, "script execution failed", logs)
|
||||
assert.Equal(t, response, logs)
|
||||
})
|
||||
t.Run("throw 500", func(t *testing.T) {
|
||||
ts := httptest.NewTLSServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
|
||||
responseWriter.WriteHeader(http.StatusInternalServerError)
|
||||
}))
|
||||
defer ts.Close()
|
||||
|
||||
client := ts.Client()
|
||||
|
||||
jenkinsClient := &jenkins{}
|
||||
jenkinsClient.Server = ts.URL
|
||||
jenkinsClient.Requester = &gojenkins.Requester{
|
||||
Base: ts.URL,
|
||||
SslVerify: true,
|
||||
Client: client,
|
||||
BasicAuth: &gojenkins.BasicAuth{Username: "unused", Password: "unused"},
|
||||
}
|
||||
|
||||
logs, err := jenkinsClient.executeScript(script, verifier)
|
||||
assert.EqualError(t, err, "invalid status code '500', logs ''", logs)
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
package client
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
||||
type userTokenResponseData struct {
|
||||
Name string `json:"tokenName"`
|
||||
UUID string `json:"tokenUuid"`
|
||||
Value string `json:"tokenValue"`
|
||||
}
|
||||
|
||||
type userTokenResponse struct {
|
||||
Status string `json:"status"`
|
||||
Data userTokenResponseData `json:"data"`
|
||||
}
|
||||
|
||||
// UserToken defines user token for Jenkins API communication
|
||||
type UserToken struct {
|
||||
raw *userTokenResponse
|
||||
base string
|
||||
}
|
||||
|
||||
// GetToken returns user token
|
||||
func (token *UserToken) GetToken() string {
|
||||
return token.raw.Data.Value
|
||||
}
|
||||
|
||||
func (jenkins *jenkins) GenerateToken(userName, tokenName string) (*UserToken, error) {
|
||||
token := &UserToken{raw: new(userTokenResponse),
|
||||
base: fmt.Sprintf("/user/%s/descriptorByName/jenkins.security.ApiTokenProperty/generateNewToken", userName)}
|
||||
endpoint := token.base
|
||||
data := map[string]string{"newTokenName": tokenName}
|
||||
r, err := jenkins.Requester.Post(endpoint, nil, token.raw, data)
|
||||
if err != nil {
|
||||
return nil, errors.Wrap(err, "couldn't generate API token")
|
||||
}
|
||||
defer r.Body.Close()
|
||||
|
||||
if r.StatusCode == http.StatusOK {
|
||||
if token.raw.Status == "ok" {
|
||||
return token, nil
|
||||
}
|
||||
|
||||
return nil, errors.New(token.raw.Status)
|
||||
}
|
||||
|
||||
return nil, errors.Errorf("couldn't generate API token: %d", r.StatusCode)
|
||||
}
|
||||
Reference in New Issue
Block a user