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)