def fetch_hashes(dlrn, link, count=1):
'''Get the commit and distro hashes for a specific promotion link'''
logger = logging.getLogger('promoter')
params = dlrnapi_client.PromotionQuery()
params.promote_name = link
try:
api_response = dlrn.api_promotions_get(params)
except ApiException:
logger.error('Exception when calling api_promotions_get: %s',
ApiException)
raise
if len(api_response) == 0:
return None
if count <= 1:
return api_response[0].to_dict()
else:
unduplicated_response = []
for hashes in api_response:
hashes = hashes.to_dict()
existing_hashes = [(ex_hashes['commit_hash'],
ex_hashes['distro_hash'])
for ex_hashes in unduplicated_response]
if (hashes['commit_hash'],
hashes['distro_hash']) not in existing_hashes:
unduplicated_response.append(hashes)
return unduplicated_response[:count]
def __init__(self, config):
"""
like all the the other inits around this code, the init will gather
relevant information for this class and put them into local shortcuts
:param config: The global promoter config or the reduced dlrnclient
config
"""
self.config = config
# TODO(gcerami): fix credentials gathering
dlrnapi_client.configuration.password = self.config.dlrnauth_password
dlrnapi_client.configuration.username = self.config.dlrnauth_username
api_client = dlrnapi_client.ApiClient(host=self.config.api_url)
self.api_instance = dlrnapi_client.DefaultApi(api_client=api_client)
self.last_promotions = {}
# Variable to detect changes on the hash while we are running a
# promotion
self.named_hashes_map = {}
# This way of preparing parameters and configuration is copied
# directly from dlrnapi CLI and ansible module
self.hashes_params = dlrnapi_client.PromotionQuery()
self.jobs_params = dlrnapi_client.Params2()
self.jobs_params_aggregate = dlrnapi_client.Params3()
self.report_params = dlrnapi_client.Params3()
self.promote_params = dlrnapi_client.Promotion()
self.log.debug("Promoter DLRN client: API URL: {}, user: {}"
"".format(api_client.host,
self.config.dlrnauth_username))
def get_last_promotion(dlrn, release, name):
query = dlrnapi_client.PromotionQuery()
query.promote_name = name
promotions = dlrn.api_promotions_get(query)
last_promotion = promotions[0].to_dict()
last_promotion['release'] = release
return last_promotion
def check_dlrn_promoted_hash(stage_info):
''' Check that the commit, distro hash has been promoted to
promotion_target as recorded in DLRN. '''
dlrn_host = stage_info['dlrn_host']
promotion_target = stage_info['promotion_target']
commit_hash = stage_info['promotions']['promotion_candidate'][
'commit_hash']
distro_hash = stage_info['promotions']['promotion_candidate'][
'distro_hash']
logger = logging.getLogger('TestPromoter')
api_client = dlrnapi_client.ApiClient(host=dlrn_host)
dlrn = dlrnapi_client.DefaultApi(api_client=api_client)
params = dlrnapi_client.PromotionQuery()
params.commit_hash = commit_hash
params.distro_hash = distro_hash
try:
api_response = dlrn.api_promotions_get(params)
logger.debug(api_response)
except dlrnapi_client.rest.ApiException:
logger.error('Exception when calling api_promotions_get: %s',
dlrnapi_client.rest.ApiException)
raise
error_message = ("Expected commit hash: {}"
" has not been promoted to {}."
"".format(commit_hash, promotion_target))
conditions = [(promotion.promote_name == promotion_target)
for promotion in api_response]
assert any(conditions), error_message
def check_trigger_condition(dlrn, promotion_name, wait_job_name,
launch_job_name):
"""
Check if launch job has to run looking for the wait job at the latest
DLRN promotion, the wait job has to be at success state.
This just look at latest promotion and also don't retrigger if the
launch_job state is not success.
This uses to calls to the dlrnapi_client.DefaultApi:
- api_promotions_get to get the newest 'Promotion'
- api_repo_status_get to get the jobs from the 'Promotion'
Parameters
----------
dlrn : dlrnapi_client.DefaultApi
The dlrn api impl to look for promotions and repo status
promotion_name: str
The promotion name to use, tripleo-ci-testing for example
wait_job_name: str
Name of the job that have to finish with success state to for
the trigger condition to be True
launch_job_name: str
Name of the job that we want to trigger.
Returns
-------
bool
It will be True if the launch_job_name has to be triggered false
otherwise
"""
logger = logging.getLogger("dlrn-trigger")
params = dlrnapi_client.PromotionQuery()
params.promote_name = promotion_name
api_response = dlrn.api_promotions_get(params)
last_promotion = api_response[0]
logger.debug("Selected promotion: {}".format(last_promotion))
params = dlrnapi_client.Params2()
params.distro_hash = last_promotion.distro_hash
params.commit_hash = last_promotion.commit_hash
api_response = dlrn.api_repo_status_get(params)
logger.debug("CI status from promotion: {}".format(api_response))
wait_job = None
launch_job = None
# Select the first ocurrence of wait and launch job
for status in api_response:
if wait_job is None and status.job_id == wait_job_name:
wait_job = status
elif launch_job is None and status.job_id == launch_job_name:
launch_job = status
logger.info("Selected wait job build: {}".format(wait_job))
logger.info("Selected launch job build: {}".format(launch_job))
# Trigger if job is not already trigger and wait job is fine
return launch_job is None and wait_job is not None and wait_job.success
def check_promoted(dlrn, link, hashes):
''' check if hashes has ever been promoted to link'''
logger = logging.getLogger('promoter')
params = dlrnapi_client.PromotionQuery()
params.commit_hash = hashes['commit_hash']
params.distro_hash = hashes['distro_hash']
try:
api_response = dlrn.api_promotions_get(params)
except ApiException:
logger.error('Exception when calling api_promotions_get: %s',
ApiException)
raise
return any([(promotion.promote_name == link) for promotion in api_response])
def get_last_promotion(dlrn_client, release, distro, name, component=None):
query = dlrnapi_client.PromotionQuery()
query.promote_name = name
if component:
query.component = component
promotions = dlrn_client.api_promotions_get(query)
if promotions:
last_promotion = promotions[0].to_dict()
last_promotion['release'] = release
last_promotion['distro'] = distro
# sanitize dict
if last_promotion['component'] is None:
last_promotion['component'] = "none"
return last_promotion
return
def get_promotions(api_instance, options):
params = dlrnapi_client.PromotionQuery() # PromotionQuery
if options.commit_hash:
params.commit_hash = options.commit_hash
if options.distro_hash:
params.distro_hash = options.distro_hash
if options.promote_name:
params.promote_name = options.promote_name
if options.offset:
params.offset = options.offset
if options.limit:
params.limit = options.limit
try:
api_response = api_instance.api_promotions_get(params)
return api_response
except ApiException as e:
raise e
def check_dlrn_promoted_hash(stage_info=None, **kwargs):
"""
Check that the the supposed hash has been promoted to
promotion_target as recorded in DLRN.
:param stage_info: a dictionary containing parameter of the staging env
:param kwargs: additional parameter for non-staged executions
:return: None
"""
if stage_info is not None:
# We are checking a stage
api_url = stage_info['dlrn']['server']['api_url']
promotion_target = stage_info['dlrn']['promotion_target']
candidate_commit = \
stage_info['dlrn']['promotions']['promotion_candidate']
candidate_hash = DlrnHash(source=candidate_commit)
api_client = dlrnapi_client.ApiClient(host=api_url)
dlrn_client = dlrnapi_client.DefaultApi(api_client=api_client)
params = dlrnapi_client.PromotionQuery()
params.limit = 1
params.promote_name = promotion_target
else:
# We are checking production server
# TODO(gcerami) implement this branch ?
pass
try:
api_response = dlrn_client.api_promotions_get(params)
log.debug(api_response)
except dlrnapi_client.rest.ApiException:
log.error('Exception when calling api_promotions_get: %s',
dlrnapi_client.rest.ApiException)
raise
error_msg = "No promotions for hash {}".format(candidate_hash)
assert api_response != [], error_msg
promotion_hash = DlrnHash(source=api_response[0])
error_message = ("Expected full hash: {}"
" has not been promoted to {}."
"".format(promotion_hash.full_hash, promotion_target))
conditions = [(promotion.promote_name == promotion_target)
for promotion in api_response]
assert any(conditions), error_message
def get_promotions(release, promote_name):
host = get_endpoint(release)
api_client = dlrnapi_client.ApiClient(host=host)
api_instance = dlrnapi_client.DefaultApi(api_client=api_client)
params = dlrnapi_client.PromotionQuery()
if promote_name:
params.promote_name = promote_name
try:
api_response = api_instance.api_promotions_get(params)
except ApiException as e:
print("Exception when calling DefaultApi->api_promotions_get: %s\n" %
e)
return api_response
def test_str_api_object(self):
params = dlrnapi_client.PromotionQuery()
str_params = str_api_object(params)
self.assertNotIn("\n", str(str_params))
