def update_credential(configMap, username, **key_args):
auth = configMap['Global']['server']['jenkins']
username = auth.get('user')
password = auth.get('password')
jenkins_url = key_args.get('url')
creds_description1 = key_args.get('credential_description')
try:
jenkins = Jenkins(jenkins_url,
username=username,
password=password,
requester=CrumbRequester(baseurl=jenkins_url,
username=username,
password=password))
creds = jenkins.credentials
cred_dict = {
'description': creds_description1,
'userName': values.access_key[0],
'password': values.access_key[1]
}
if values.DryRun is True:
logging.info(' Dry run: ' + jenkins_url)
else:
try:
creds[creds_description1] = UsernamePasswordCredential(
cred_dict)
logging.info(' Key written to ' + jenkins_url)
except:
logging.error(' Key write failed at: ' + jenkins_url)
except:
logging.error(
' ***** Exception trying to modify Key at %s - Key may need to be updated manually'
% jenkins_url)
def run_jenkins_jobs(major, tag):
print(str.format('starting jenkins jobs for {0}: {1}...', major, tag))
if 'JENKINS_CREDENTIALS' not in os.environ:
return
jenkins_url = 'https://ci.sapmachine.io'
jenkins_user = os.environ['JENKINS_CREDENTIALS_USR']
jenkins_password = os.environ['JENKINS_CREDENTIALS_PSW']
server = Jenkins(jenkins_url,
username=jenkins_user,
password=jenkins_password,
requester=CrumbRequester(baseurl=jenkins_url,
username=jenkins_user,
password=jenkins_password))
# strange, but with that one I got a 403: https://ci.sapmachine.io/view/Infrastructure/job/repository-tags/191/
# server.use_auth_cookie()
build_jobs = [
str.format('build-{0}-release-linux_x86_64', major),
str.format('build-{0}-release-linux_ppc64le', major),
str.format('build-{0}-release-linux_ppc64', major),
str.format('build-{0}-release-linux_aarch64', major),
str.format('build-{0}-release-macos_x86_64', major),
str.format('build-{0}-release-windows_x86_64', major)
]
job_params = {'PUBLISH': 'true', 'RELEASE': 'false', 'GIT_TAG_NAME': tag}
for job in build_jobs:
print(str.format('starting jenkins job "{0}" ...', job))
server.build_job(job, job_params)
def __init__(self, url, username, password):
self.server = Jenkins(url,
username='******',
password='******',
requester=CrumbRequester(baseurl=url,
username='******',
password='******'))
def run_jenkins_jobs(major, tag):
if 'JENKINS_CREDENTIALS' not in os.environ:
return
jenkins_url = 'https://ci.sapmachine.io'
jenkins_user = os.environ['JENKINS_CREDENTIALS_USR']
jenkins_password = os.environ['JENKINS_CREDENTIALS_PSW']
server = Jenkins(jenkins_url,
username=jenkins_user,
password=jenkins_password,
requester=CrumbRequester(baseurl=jenkins_url,
username=jenkins_user,
password=jenkins_password))
build_jobs = [
str.format('build-{0}-release-linux_x86_64', major),
str.format('build-{0}-release-linux_ppc64le', major),
str.format('build-{0}-release-linux_ppc64', major),
str.format('build-{0}-release-macos_x86_64', major),
str.format('build-{0}-release-windows_x86_64', major)
]
job_params = {
'PUBLISH': 'true',
'RELEASE': 'false',
'RUN_TESTS': 'true',
'GIT_TAG_NAME': tag
}
for job in build_jobs:
print(str.format('starting jenkins job "{0}" ...', job))
server.build_job(job, job_params)
def crumbed_jenkins(jenkins):
ENABLE_CRUMBS_CONFIG.update(SECURITY_SETTINGS)
DISABLE_CRUMBS_CONFIG.update(SECURITY_SETTINGS)
jenkins.requester.post_and_confirm_status(
urljoin(jenkins.baseurl, '/configureSecurity/configure'),
data={
'Submit': 'save',
'json': json.dumps(ENABLE_CRUMBS_CONFIG)
},
headers={'Content-Type': 'application/x-www-form-urlencoded'})
log.info('Enabled Jenkins security')
crumbed = Jenkins(jenkins.baseurl,
requester=CrumbRequester(baseurl=jenkins.baseurl))
yield crumbed
crumbed.requester.post_and_confirm_status(
jenkins.baseurl + '/configureSecurity/configure',
data={
'Submit': 'save',
'json': json.dumps(DISABLE_CRUMBS_CONFIG)
},
headers={'Content-Type': 'application/x-www-form-urlencoded'})
log.info('Disabled Jenkins security')
def __init__(self, job_name):
self.info = settings.JENKINS_INFO
self.cr = CrumbRequester(**self.info)
self.jclient = Jenkins(requester=self.cr, **self.info)
if not self.jclient.has_job(job_name):
raise InvalidJobError('No job named {}'.format(job_name))
self.job =self.jclient.get_job(job_name)
def connet_jenkinsjob(self): #连接Jenkins的job
jenkins = Jenkins(jenkins_url,
username=jenkins_user,
password=jenkins_user,
requester=CrumbRequester(username=jenkins_user,
password=jenkins_password,
baseurl=jenkins_url))
return jenkins
def loadjenkins():
config.read("config.ini")
global server,crumb,jenkins_username,jenkins_token,jenkins_url
jenkins_username=config.get("JENKINSPARAMETER", "username")
jenkins_token=config.get("JENKINSPARAMETER", "token")
jenkins_url=config.get("JENKINSPARAMETER", "jenkins_url")
crumb = CrumbRequester(username=jenkins_username, password=jenkins_token, baseurl=jenkins_url)
server = Jenkins(jenkins_url, username=jenkins_username, password=jenkins_token, requester=crumb, timeout=10)
def create_jenkins():
jenkins = Jenkins(usr_url,
username=usr_name,
password=usr_pass,
requester=CrumbRequester(baseurl=usr_url,
username=usr_name,
password=usr_pass))
return jenkins
def __init__(self, *args, **kwargs):
crumb_requester = CrumbRequester(baseurl=qube_ci_addr,
username=qube_user,
password=qube_pwd)
self.server = Jenkins(qube_ci_addr,
username=qube_user,
password=qube_pwd,
requester=crumb_requester)
def process_request(
host_name: str,
host_port: str,
job_name: str,
credentials_id: str,
repository_url: str,
commit_id: str,
command_prebuild: str,
command_run: str,
label: str
) -> None:
"""
Process a request
:param host_name: (str) String with the name of the remote host
:param host_port: (int) Port number of the remote host
:param job_name: (str) Name of a job to run
:param credentials_id: (str) Jenkins credentials id to be used during repository fetch
:param repository_url: (str) Repository URL with code to be run remotely
:param commit_id: (str) Commit id
:param command_prebuild: (str) Command to be executed before the docker build
:param command_run: (str) Command to execute
:param label: (str) Label of the machine to execute on
"""
assert host_name is not None, 'Host name is required'
assert host_port is not None, 'Port number is required'
assert job_name is not None, 'Job name is required'
assert credentials_id is not None, 'Credentials ID is required'
assert repository_url is not None, 'Repository URL is required'
assert commit_id is not None, 'Commit ID is required'
assert command_prebuild is not None, 'Prebuild command is required'
assert command_run is not None, 'Run command is required'
assert label is not None, 'Label is required'
if host_port == '80':
url = 'http://' + host_name
else:
url = 'http://' + host_name + ':' + host_port
server = Jenkins(
url,
requester=CrumbRequester(baseurl=url)
)
build_params = {
'commit_id': commit_id,
'command_prebuild': command_prebuild,
'command_run': command_run,
'label': label,
'credentials_id': credentials_id,
'repository_url': repository_url,
}
job = server[job_name]
job.invoke(build_params=build_params)
build = job.get_last_build()
print("Build queued:")
print(build.get_result_url())
def __run(self):
jenkins_url = f'http://{self.host}:{self.port}/'
crumb_requester = CrumbRequester(baseurl=jenkins_url,
username=username,
password=password)
server = Jenkins(jenkins_url,
username=username,
password=password,
requester=crumb_requester)
server[job_name].invoke()
def test_generate_new_api_token(jenkins_admin_admin):
jenkins_admin_admin.requester = CrumbRequester(
baseurl=jenkins_admin_admin.baseurl,
username=jenkins_admin_admin.username,
password=jenkins_admin_admin.password
)
jenkins_admin_admin.poll()
new_token = jenkins_admin_admin.generate_new_api_token() # generate new token
log.info('newly generated token: %s', new_token)
assert new_token is not None
def load(self):
"""Loads the Jenkins object"""
# Resets the logging level.
logger = logging.getLogger('jenkinsapi.job')
logger.setLevel(logging.WARNING)
logger = logging.getLogger('jenkinsapi.build')
logger.setLevel(logging.WARNING)
# Loads the jenkins object.
self._jenkins = jenkins.Jenkins(self.url, requester=CrumbRequester(baseurl=self.url))
def get_server_instance():
jenkins_url = 'http://10.10.16.160:8090'
user = "******"
passwd = "sd-9898w"
requester = CrumbRequester(baseurl=jenkins_url,
username=user,
password=passwd)
server = Jenkins(jenkins_url,
username=user,
password=passwd,
requester=requester)
return server
def jenkins_connection():
jenkins_url = 'http://127.0.0.1:8080/'
username = '******'
password = '******'
jenkins = Jenkins(jenkins_url,
username=username,
password=password,
requester=CrumbRequester(
baseurl=jenkins_url,
username=username,
password=password,
))
return jenkins
def postUrl(jobname, parameter):
loadjenkins()
crumb = CrumbRequester(username=jenkins_username,
password=jenkins_token,
baseurl=jenkins_url)
logging.debug("Jobname " + jobname)
logging.debug("Parameter List " + json.dumps(parameter))
jenkins = Jenkins(jenkins_url,
username=jenkins_username,
password=jenkins_token,
requester=crumb,
timeout=30)
jenkins.build_job(jobname, parameter)
def _get_jenkins_instance(self):
"""Return jenkins object instance.
Returns:
(:obj:`Jenkins`): Jenkins object instance.
"""
jenkins_obj = Jenkins(self.jenkins_url,
requester=CrumbRequester(self.jenkins_username,
self.jenkins_password,
baseurl=self.jenkins_url,
ssl_verify=False))
LOG.debug('Connected to Jenkins, Version: %s' % jenkins_obj.version)
return jenkins_obj
def process_request(host_name: str, host_port: str, job_name: str,
credentials_id: str, repository_url: str, artifacts: str,
file_name: str, commit_id: str, parameters: str,
target_labels: str) -> None:
"""
Process a request
:param host_name: (str) String with the name of the remote host
:param host_port: (int) Port number of the remote host
:param job_name: (str) Name of a job to run
:param credentials_id: (str) Jenkins credentials id to be used during repository fetch
:param repository_url: (str) Repository URL with code to be run remotely
:param artifacts: (str) Mask of artifacts (calculation result files)
:param file_name: (str) Name of the file to be run remotely
:param commit_id: (str) Commit id
:param parameters: (str) Additional parameters for python script to be run remotely
:param target_labels: (str) Target labels
"""
assert host_name is not None, 'Host name is required'
assert host_port is not None, 'Port number is required'
assert job_name is not None, 'Job name is required'
assert credentials_id is not None, 'Credentials ID is required'
assert repository_url is not None, 'Repository URL is required'
assert file_name is not None, 'File name is required'
assert commit_id is not None, 'Commit ID is required'
if host_port == '80':
url = 'http://' + host_name
else:
url = 'http://' + host_name + ':' + host_port
server = Jenkins(url, requester=CrumbRequester(baseurl=url))
build_params = {
'file_name': file_name,
'commit_id': commit_id,
'parameters': parameters,
'target_labels': target_labels,
'credentials_id': credentials_id,
'repository_url': repository_url,
"artifacts_path": artifacts
}
job = server[job_name]
job.invoke(build_params=build_params)
build = job.get_last_build()
print("Build queued:")
print(build.get_result_url())
def get_jenkins_instance(user, token):
"""
TODO
:param user:
:param token:
:return:
"""
# Jenkins Server
crumb_requester = CrumbRequester(baseurl=JENKINS_URL,
username=user,
password=token)
jenkins_server = Jenkins(baseurl=JENKINS_URL,
username=user,
password=token,
requester=crumb_requester)
return jenkins_server
def run_job(job_name: str, params: dict):
jenkins_api_token = os.getenv('JENKINS_API_TOKEN')
crumb = CrumbRequester(username='******',
password=jenkins_api_token,
baseurl=jenkins_url)
jenkins = Jenkins(jenkins_url,
username='******',
password=jenkins_api_token,
requester=crumb,
timeout=60)
jenkins.build_job(job_name, params)
job = jenkins[job_name]
qi = job.invoke(build_params=params)
tries = 0
while not qi.is_queued():
if tries > 10:
break
time.sleep(1)
tries += 1
if qi.is_queued() or qi.is_running():
qi.block_until_complete(delay=3)
build = qi.get_build()
while build.is_running():
print('.')
time.sleep(5)
is_build_good = build.is_good()
if is_build_good is not True:
print("build faild")
print(build.get_console())
sys.exit(1)
if is_build_good is True:
print(job_name + " is successful")
def __init__(self, PublicIP, username, password):
execLog.debug('Object - Created Class Object')
response = urllib2.urlopen(PublicIP)
JenkinsURL = 'http://{}:8080'.format(response.read())
execLog.debug('Jen URL - {}'.format(JenkinsURL))
requester = CrumbRequester(baseurl=JenkinsURL,
username=username,
password=password)
self.server = Jenkins(JenkinsURL,
username=username,
password=password,
requester=requester)
version = self.server.version
execLog.info('Jenkins Server Version is : {}'.format(version))
user = self.server.username
execLog.info('Logged in to Jenkins as : {}'.format(user))
def crumbed_jenkins(jenkins):
jenkins.requester.post_and_confirm_status(
urljoin(jenkins.baseurl, '/configureSecurity/configure'),
data={
'Submit': 'save',
'json': json.dumps(ENABLE_CRUMBS_CONFIG)
},
headers={'Content-Type': 'application/x-www-form-urlencoded'})
crumbed = Jenkins(jenkins.baseurl,
requester=CrumbRequester(baseurl=jenkins.baseurl))
yield crumbed
crumbed.requester.post_and_confirm_status(
jenkins.baseurl + '/configureSecurity/configure',
data={
'Submit': 'save',
'json': json.dumps(DISABLE_CRUMBS_CONFIG)
},
headers={'Content-Type': 'application/x-www-form-urlencoded'})
def update_jenkins_tag(base_url, application_name, tag_name):
crumb_requester = CrumbRequester(baseurl=base_url,
username='******',
password='******')
J = Jenkins(base_url,
username='******',
password='******',
requester=crumb_requester)
key1 = J[application_name]
c = key1.get_config()
c = str(c)
c = re.sub('<name>tag_\d+\.\d</name>', '<name>' + tag_name + '</name>', c)
response_info = key1.update_config(c, full_response=True)
if response_info.status_code == 200:
return True
else:
print "Update the specific application tag Failed."
print response_info.text
return False
def setUp(self):
try:
port = jenkinsapi_tests.systests.state['launcher'].http_port
except KeyError:
log.warning(
"Jenkins was not launched from the test-framework, "
"assuming port %i" %
DEFAULT_JENKINS_PORT)
port = DEFAULT_JENKINS_PORT
self.jenkins = Jenkins('http://localhost:%d' % port)
self.jenkins.requester.post_and_confirm_status(
self.jenkins.baseurl + '/configureSecurity/configure',
data={
'Submit': 'save',
'json': json.dumps(ENABLE_CRUMBS_CONFIG)
},
headers={'Content-Type': 'application/x-www-form-urlencoded'}
)
self.jenkins = Jenkins(
self.jenkins.baseurl,
requester=CrumbRequester(baseurl=self.jenkins.baseurl))
def crumbed_jenkins(jenkins):
if '2.x' in os.environ.get('JENKINS_VERSION', '1.x'):
ENABLE_CRUMBS_CONFIG.update(JENKINS2_SSHD_SETTINGS)
DISABLE_CRUMBS_CONFIG.update(JENKINS2_SSHD_SETTINGS)
jenkins.requester.post_and_confirm_status(
urljoin(jenkins.baseurl, '/configureSecurity/configure'),
data={
'Submit': 'save',
'json': json.dumps(ENABLE_CRUMBS_CONFIG)
},
headers={'Content-Type': 'application/x-www-form-urlencoded'})
crumbed = Jenkins(jenkins.baseurl,
requester=CrumbRequester(baseurl=jenkins.baseurl))
yield crumbed
crumbed.requester.post_and_confirm_status(
jenkins.baseurl + '/configureSecurity/configure',
data={
'Submit': 'save',
'json': json.dumps(DISABLE_CRUMBS_CONFIG)
},
headers={'Content-Type': 'application/x-www-form-urlencoded'})
def trigger_build(base_url,
user_name,
user_token,
job_name,
job_token,
job_cause=None,
job_params=None,
timeout=60 * 30):
u"""
Trigger a jenkins job/project (note that jenkins uses these terms interchangeably)
Args:
base_url (str): The base URL for the jenkins server, e.g. https://test-jenkins.testeng.edx.org
user_name (str): The jenkins username
user_token (str): API token for the user. Available at {base_url}/user/{user_name)/configure
job_name (str): The Jenkins job name, e.g. test-project
job_token (str): Jobs must be configured with the option "Trigger builds remotely" selected.
Under this option, you must provide an authorization token (configured in the job)
in the form of a string so that only those who know it would be able to remotely
trigger this project's builds.
job_cause (str): Text that will be included in the recorded build cause
job_params (set of tuples): Parameter names and their values to pass to the job
timeout (int): The maximum number of seconds to wait for the jenkins build to complete (measured
from when the job is triggered.)
Returns:
A the status of the build that was triggered
Raises:
BackendError: if the Jenkins job could not be triggered successfully
"""
@backoff.on_predicate(
backoff.constant,
interval=60,
max_tries=timeout / 60 + 1,
on_giveup=_poll_giveup,
# We aren't worried about concurrent access, so turn off jitter
jitter=None,
)
def poll_build_for_result(build):
u"""
Poll for the build running, with exponential backoff, capped to ``timeout`` seconds.
The on_predicate decorator is used to retry when the return value
of the target function is True.
"""
return not build.is_running()
# Create a dict with key/value pairs from the job_params
# that were passed in like this: --param FOO bar --param BAZ biz
# These will get passed to the job as string parameters like this:
# {u'FOO': u'bar', u'BAX': u'biz'}
request_params = {}
for param in job_params:
request_params[param[0]] = param[1]
# Contact jenkins, log in, and get the base data on the system.
try:
crumb_requester = CrumbRequester(baseurl=base_url,
username=user_name,
password=user_token,
ssl_verify=True)
jenkins = Jenkins(base_url,
username=user_name,
password=user_token,
requester=crumb_requester)
except (JenkinsAPIException, HTTPError) as err:
raise BackendError(str(err))
if not jenkins.has_job(job_name):
msg = u'Job not found: {}.'.format(job_name)
msg += u' Verify that you have permissions for the job and double check the spelling of its name.'
raise BackendError(msg)
# This will start the job and will return a QueueItem object which can be used to get build results
job = jenkins[job_name]
queue_item = job.invoke(securitytoken=job_token,
build_params=request_params,
cause=job_cause)
LOG.info(u'Added item to jenkins. Server: {} Job: {} '.format(
jenkins.base_server_url(), queue_item))
# Block this script until we are through the queue and the job has begun to build.
queue_item.block_until_building()
build = queue_item.get_build()
LOG.info(u'Created build {}'.format(build))
LOG.info(u'See {}'.format(build.baseurl))
# Now block until you get a result back from the build.
poll_build_for_result(build)
# Update the build's internal state, so that the final status is available
build.poll()
status = build.get_status()
LOG.info(u'Build status: {status}'.format(status=status))
return status
def __init__(self, *args, **kwargs):
requester_kwargs = copy.copy(kwargs)
requester_kwargs['baseurl'] = args[0]
kwargs['requester'] = CrumbRequester(**requester_kwargs)
super(JenkinsProxy, self).__init__(*args, **kwargs)
self.__jobs = None
"""
Example of using CrumbRequester - when CSRF protection is enable in Jenkins
"""
from jenkinsapi.jenkins import Jenkins
from jenkinsapi.utils.crumb_requester import CrumbRequester
jenkins = Jenkins('http://localhost:8080',
username='******',
password='******',
requester=CrumbRequester(baseurl='http://localhost:8080',
username='******',
password='******'))
for job_name in jenkins.jobs:
print job_name
from __future__ import print_function from pkg_resources import resource_string from jenkinsapi.jenkins import Jenkins from jenkinsapi.utils.crumb_requester import CrumbRequester url = "jenkinsURL" username = "******" password = "******" crumb_requester = CrumbRequester(baseurl=url, username=username, password=password) j = Jenkins(url, username=username, password=password, requester=crumb_requester) job_name = 'jaydeepCreatedByPythonTest-4' xml = resource_string(__name__, 'job.xml') print(xml) job = j.create_job(jobname=job_name, xml=xml) # Get job from Jenkins by job name my_job = j[job_name] print(my_job)
