def bintray_repo_delete_version(self, repo, package_name, repository, build_version=None): """Delete the given bintray repository version if it exsts.""" try: bintray_url = self.__to_bintray_url(repo, package_name, repository, build_version) logging.debug('Checking for %s', bintray_url) request = urllib2.Request(url=bintray_url) request.get_method = lambda: 'DELETE' self.__add_bintray_auth_header(request) labels = { 'repo': repo, 'repository': repository.name, 'artifact': 'debian' } self.__metrics.count_call( 'DeleteArtifact', labels, 'Attempts to delete versioned artifacts on bintray', urllib2.urlopen, request) return True except urllib2.HTTPError as ex: if ex.code == 404: return True raise_and_log_error( ResponseError('Bintray failure: {}'.format(ex), server='bintray.delete'), 'Failed on url=%s: %s' % (bintray_url, ex.message))
def bintray_repo_has_version(self, repo, package_name, repository, build_version=None, build_number=None): """See if the given bintray repository has the package version to build.""" try: bintray_url = self.__to_bintray_url(repo, package_name, repository, build_version=build_version, build_number=build_number) logging.debug('Checking for %s', bintray_url) request = urllib2.Request(url=bintray_url) self.__add_bintray_auth_header(request) urllib2.urlopen(request) return True except urllib2.HTTPError as ex: if ex.code == 404: return False raise_and_log_error( ResponseError('Bintray failure: {}'.format(ex), server='bintray.check'), 'Failed on url=%s: %s' % (bintray_url, ex.message)) except Exception as ex: raise
def bintray_repo_delete_version(self, repo, package_name, repository, build_version=None): """Delete the given bintray repository version if it exsts.""" try: bintray_url = self.__to_bintray_url(repo, package_name, repository, build_version) logging.debug("Checking for %s", bintray_url) request = Request(url=bintray_url) request.get_method = lambda: "DELETE" self.__add_bintray_auth_header(request) labels = { "repo": repo, "repository": repository.name, "artifact": "debian" } self.__metrics.count_call("DeleteArtifact", labels, urlopen, request) return True except HTTPError as ex: if ex.code == 404: return True raise_and_log_error( ResponseError("Bintray failure: {}".format(ex), server="bintray.delete"), "Failed on url=%s: %s" % (bintray_url, exception_to_message(ex)), )
def __validate_service_base_url(self, service_name, timeout=None): service_config = self.__public_service_configs[service_name] base_url = service_config["base_url"] timeout = timeout or self.options.test_service_startup_timeout end_time = time.time() + timeout logging.info('Validating base URL of "%s"...', service_name) try: url = "{base_url}/health".format(base_url=base_url) request = Request(url=url) if "bearer_auth_token" in service_config: request.add_header( "Authorization", "Bearer {}".format(service_config["bearer_auth_token"]), ) context = None if self.options.test_ignore_ssl_cert_verification: context = ssl._create_unverified_context() urlopen(request, context=context) logging.info('"%s" is ready on service endpoint %s', service_name, base_url) return except HTTPError as error: logging.error("%s service endpoint got %s.", service_name, error) raise_and_log_error( ResponseError( "{0} service endpoint got {1}".format(service_name, error), server=base_url, )) except Exception as error: raise_and_log_error( ResponseError( "{0} service endpoint got {1}".format(service_name, error), server=base_url, )) except URLError as error: if time.time() >= end_time: logging.error("Timing out waiting for %s", service_name) raise_and_log_error( TimeoutError(service_name, cause=service_name)) raise
def __init__(self, options): self.__options = options self.__hal_path = options.hal_path logging.debug('Retrieving halyard runtime configuration.') url = 'http://' + options.halyard_daemon + '/resolvedEnv' response = urllib2.urlopen(url) if response.getcode() >= 300: raise_and_log_error( ResponseError('{url}: {code}\n{body}'.format( url=url, code=response.getcode(), body=response.read()), server='halyard')) self.__halyard_runtime_config = yaml.load(response)
def __init__(self, options): self.__options = options self.__hal_path = options.hal_path logging.debug('Retrieving halyard runtime configuration.') url = 'http://' + options.halyard_daemon + '/resolvedEnv' try: response = urlopen(url) except HTTPError as error: raise_and_log_error( ResponseError('{url}: {code}\n{body}'.format( url=url, code=error.code, body=response.read()), server='halyard')) self.__halyard_runtime_config = yaml.safe_load(response)
def __validate_service_base_url(self, service_name, timeout=None): service_config = self.__public_service_configs[service_name] base_url = service_config['base_url'] timeout = timeout or self.options.test_service_startup_timeout end_time = time.time() + timeout logging.info('Validating base URL of "%s..."', service_name) try: if 'bearer_auth_token' in service_config: _make_get_request_with_bearer_auth_token( '{base_url}/health'.format(base_url=base_url), service_config['bearer_auth_token']) # Add more authentication cases here. else: urlopen('{base_url}/health'.format(base_url=base_url)) logging.info('"%s" is ready on service endpoint %s', service_name, base_url) return except HTTPError as error: logging.error('%s service endpoint got %s.', service_name, error) raise_and_log_error( ResponseError('{0} service endpoint got {1}'.format( service_name, error), server=base_url)) except Exception as error: raise_and_log_error( ResponseError('{0} service endpoint got {1}'.format( service_name, error), server=base_url)) except URLError as error: if time.time() >= end_time: logging.error('Timing out waiting for %s', service_name) raise_and_log_error( TimeoutError(service_name, cause=service_name)) raise
def fetch_bintray_url(self, bintray_url): request = Request(bintray_url) if self.__basic_auth: request.add_header('Authorization', self.__basic_auth) try: response = urlopen(request) headers = response.info() payload = response.read() content = json.JSONDecoder(encoding='utf-8').decode(payload) except HTTPError as ex: raise_and_log_error( ResponseError('Bintray failure: {}'.format(ex), server='bintray.api'), 'Failed on url=%s: %s' % (bintray_url, exception_to_message(ex))) except Exception as ex: raise return headers, content
def __init__(self, options): self.__options = options self.__hal_path = options.hal_path logging.debug("Retrieving halyard runtime configuration.") url = "http://" + options.halyard_daemon + "/resolvedEnv" try: response = urlopen(url) except HTTPError as error: raise_and_log_error( ResponseError( "{url}: {code}\n{body}".format(url=url, code=error.code, body=error.read()), server="halyard", )) self.__halyard_runtime_config = yaml.safe_load(response)
def bintray_repo_has_version(self, repo, package_name, repository, build_version): """See if the given bintray repository has the package version to build.""" try: bintray_url = self.__to_bintray_url(repo, package_name, repository, build_version) logging.debug("Checking for %s", bintray_url) request = Request(url=bintray_url) self.__add_bintray_auth_header(request) urlopen(request) return True except HTTPError as ex: if ex.code == 404: return False raise_and_log_error( ResponseError("Bintray failure: {}".format(ex), server="bintray.check"), "Failed on url=%s: %s" % (bintray_url, exception_to_message(ex)), ) except Exception as ex: raise
def wait_on_service(self, service_name, port=None, timeout=None): """Wait for the given service to be available on the specified port. Args: service_name: [string] The service name we we are waiting on. port: [int] The remote port the service is at. timeout: [int] How much time to wait before giving up. Returns: The ForwardedPort entry for this service. """ try: with self.__lock: forwarding = self.__forwarded_ports.get(service_name) if forwarding is None: forwarding = self.__forward_port_to_service(service_name) self.__forwarded_ports[service_name] = forwarding except Exception: logging.exception( 'Exception while attempting to forward ports to "%s"', service_name) raise timeout = timeout or self.options.test_service_startup_timeout end_time = time.time() + timeout logging.info('Waiting on "%s..."', service_name) if port is None: port = self.__service_port_map[service_name] # It seems we have a race condition in the poll # where it thinks the jobs have terminated. # I've only seen this happen once. time.sleep(1) threadid = hex(threading.current_thread().ident) logging.info('WaitOn polling %s from thread %s', service_name, threadid) while forwarding.child.poll() is None: try: # localhost is hardcoded here because we are port forwarding. # timeout=20 is to appease kubectl port forwarding, which will close # if left idle for 30s urlopen('http://localhost:{port}/health'.format( port=forwarding.port), timeout=20) logging.info('"%s" is ready on port %d | %s', service_name, forwarding.port, threadid) return forwarding except HTTPError as error: logging.warning('%s got %s. Ignoring that for now.', service_name, error) return forwarding except (URLError, Exception) as error: if time.time() >= end_time: logging.error('Timing out waiting for %s | %s', service_name, threadid) raise_and_log_error( TimeoutError(service_name, cause=service_name)) time.sleep(2.0) logging.error( 'It appears %s is no longer available.' ' Perhaps the tunnel closed.', service_name) raise_and_log_error( ResponseError('It appears that {0} failed'.format(service_name), server='tunnel'))