def service_unavailable_predicate(service_name): url = dcos_service_url(service_name) try: http.get(url) except DCOSHTTPException as e: if e.response.status_code == 500: return True else: return False
def get_resource(resource): """:param resource: optional filename or http(s) url for the application or group resource :type resource: str :returns: resource :rtype: dict """ if resource is None: return None if os.path.isfile(resource): with util.open_file(resource) as resource_file: return util.load_json(resource_file) else: try: http.silence_requests_warnings() req = http.get(resource) if req.status_code == 200: data = b'' for chunk in req.iter_content(1024): data += chunk return util.load_jsons(data.decode('utf-8')) else: raise Exception except Exception: raise DCOSException( "Can't read from resource: {0}. Please check that it exists.". format(resource))
def test_ui_available(marathon_service_name): """Simply verifies that a request to the UI endpoint is successful if Marathon is launched.""" response = http.get("{}/ui/".format( shakedown.dcos_service_url(marathon_service_name))) assert response.status_code == 200, "HTTP status code is {}, but 200 was expected".format( response.status_code)
def mesos_available_predicate(): url = master_url() try: response = http.get(url) return response.status_code == 200 except Exception as e: return False
def service_available_predicate(service_name): url = dcos_service_url(service_name) try: response = http.get(url) return response.status_code == 200 except Exception as e: return False
def dcos_agents_state(): response = http.get(agents_url()) if response.status_code == 200: return response.json() else: return None
def browse(self, slave, path): """ GET /files/browse.json Request path:... # path to run ls on Response [ { path: # full path to file nlink: size: mtime: mode: uid: gid: } ] :param slave: slave to issue the request on :type slave: Slave :returns: /files/browse.json response :rtype: dict """ url = self.slave_url(slave['id'], slave.http_url(), 'files/browse.json') return http.get(url, params={'path': path}).json()
def http_get_marathon_path(name, marathon_name='marathon'): """Invokes HTTP GET for marathon url with name. For example, name='ping': http GET {dcos_url}/service/marathon/ping """ url = get_marathon_endpoint(name, marathon_name) headers = {'Accept': '*/*'} return http.get(url, headers=headers)
def slave_file_read(self, slave_id, private_url, path, offset, length): """See the master_file_read() docs :param slave_id: slave ID :type slave_id: str :param path: absolute path to read :type path: str :param private_url: The slave's private URL derived from its pid. Used when we're accessing mesos directly, rather than through DC/OS. :type private_url: str :param offset: start byte location, or -1. -1 means read no data, and is used to fetch the size of the file in the response's 'offset' parameter. :type offset: int :param length: number of bytes to read, or -1. -1 means read the whole file :type length: int :returns: files/read.json response :rtype: dict """ url = self.slave_url(slave_id, private_url, 'files/read.json') params = {'path': path, 'length': length, 'offset': offset} return http.get(url, params=params, timeout=self._timeout).json()
def metadata(self): """ GET /metadata :returns: /metadata content :rtype: dict """ url = self.get_dcos_url('metadata') return http.get(url, timeout=self._timeout).json()
def get_state_summary(self): """Get the Mesos master state summary json object :returns: Mesos' master state summary json object :rtype: dict """ url = self.master_url('master/state-summary') return http.get(url, timeout=self._timeout).json()
def get_master_state(self): """Get the Mesos master state json object :returns: Mesos' master state json object :rtype: dict """ url = self.master_url('master/state.json') return http.get(url, timeout=self._timeout).json()
def hosts(self, host): """ GET v1/hosts/<host> :param host: host :type host: str :returns: {'ip', 'host'} dictionary :rtype: dict(str, str) """ url = self._path('v1/hosts/{}'.format(host)) return http.get(url, headers={}).json()
def ensure_permissions(): common.set_service_account_permissions(MOM_EE_SERVICE_ACCOUNT) url = urljoin( shakedown.dcos_url(), 'acs/api/v1/acls/dcos:superuser/users/{}'.format( MOM_EE_SERVICE_ACCOUNT)) req = http.get(url) expected = '/acs/api/v1/acls/dcos:superuser/users/{}/full'.format( MOM_EE_SERVICE_ACCOUNT) assert req.json()['array'][0][ 'url'] == expected, "Service account permissions couldn't be set"
def fetch(self, path, **kwargs): """GET the resource located at `path` :param path: the URL path :type path: str :param **kwargs: http.get kwargs :type **kwargs: dict :returns: the response object :rtype: Response """ url = urllib.parse.urljoin(self._base_url(), path) return http.get(url, **kwargs)
def _download_and_store(url, location): """Download given url and store in location on disk :param url: url to download :type url: str :param location: path to file to store url :type location: str :rtype: None """ with open(location, 'wb') as f: r = http.get(url, stream=True) for chunk in r.iter_content(1024): f.write(chunk)
def test_metrics_endpoint(marathon_service_name): service_url = dcos_service_url(marathon_service_name) response = http.get("{}metrics".format(service_url)) assert response.status_code == 200, "HTTP status code {} is NOT 200".format(response.status_code) if marathon_version_less_than('1.7'): metric_name = 'service.mesosphere.marathon.app.count' else: metric_name = 'marathon.apps.active.gauge' response_json = response.json() logger.info('Found metric gauges: '.format(response_json['gauges'])) assert response_json['gauges'][metric_name] is not None, \ "{} is absent".format(metric_name)
def get_group(id): """ Returns a group from the DCOS Enterprise. It returns None if none exists. :param id: group id :type id: str :return: Group :rtype: dict """ acl_url = urljoin(_acl_url(), 'groups/{}'.format(id)) try: r = http.get(acl_url) return r.json() except DCOSHTTPException as e: if e.response.status_code != 400: raise
def get_slave_state(self, slave_id, private_url): """Get the Mesos slave state json object :param slave_id: slave ID :type slave_id: str :param private_url: The slave's private URL derived from its pid. Used when we're accessing mesos directly, rather than through DC/OS. :type private_url: str :returns: Mesos' master state json object :rtype: dict """ url = self.slave_url(slave_id, private_url, 'state.json') return http.get(url, timeout=self._timeout).json()
def get_user(uid): """ Returns a user from the DCOS Enterprise. It returns None if none exists. :param uid: user id :type uid: str :return: User :rtype: dict """ try: acl_url = urljoin(_acl_url(), 'users/{}'.format(uid)) r = http.get(acl_url) return r.json() # assert r.status_code == 201 except DCOSHTTPException as e: if e.response.status_code == 400: return None else: raise
def master_file_read(self, path, length, offset): """This endpoint isn't well documented anywhere, so here is the spec derived from the mesos source code: request format: { path: absolute path to read offset: start byte location, or -1. -1 means read no data, and is used to fetch the size of the file in the response's 'offset' parameter. length: number of bytes to read, or -1. -1 means read the whole file. } response format: { data: file data. Empty if a request.offset=-1. Could be smaller than request.length if EOF was reached, or if (I believe) request.length is larger than the length supported by the server (16 pages I believe). offset: the offset value from the request, or the size of the file if the request offset was -1 or >= the file size. } :param path: absolute path to read :type path: str :param offset: start byte location, or -1. -1 means read no data, and is used to fetch the size of the file in the response's 'offset' parameter. :type offset: int :param length: number of bytes to read, or -1. -1 means read the whole file :type length: int :returns: files/read.json response :rtype: dict """ url = self.master_url('files/read.json') params = {'path': path, 'length': length, 'offset': offset} return http.get(url, params=params, timeout=self._timeout).json()
def get_providers(): """ Returns dict of providers configured on cluster :returns: configured providers :rtype: {} """ dcos_url = config.get_config_val("core.dcos_url").rstrip('/') endpoint = '/acs/api/v1/auth/providers' url = urllib.parse.urljoin(dcos_url, endpoint) try: providers = http.get(url) return providers.json() # this endpoint should only have authentication in DC/OS 1.8 except DCOSAuthenticationException: msg = "This command is not supported for your cluster" raise DCOSException(msg) except DCOSHTTPException as e: if e.response.status_code == 404: msg = "This command is not supported for your cluster" raise DCOSException(msg) return {}
def cluster_available_predicate(url): try: response = http.get(url, verify=False) return response.status_code == 200 except Exception as e: return False
def wait_until_fail(endpoint): try: http.get(endpoint) return True except DCOSHTTPException: return False
def get_pod_status(pod_id): url = urljoin(DCOS_SERVICE_URL, get_pod_status_url(pod_id)) return http.get(url).json()
def http_get_marathon_path(name, marathon_name='marathon'): """ Invokes HTTP GET for marathon url with name ex. name='ping' http GET {dcos_url}/service/marathon/ping """ url = get_marathon_endpoint(name, marathon_name) return http.get(url)
def get_pod_version(pod_id, version_id): url = urljoin(DCOS_SERVICE_URL, get_pod_versions_url(pod_id, version_id)) return http.get(url).json()
def test_non_authorized_user(): with shakedown.new_dcos_user('kenny', 'kenny'): with pytest.raises(errors.DCOSAuthorizationException) as exec_info: http.get(urljoin(shakedown.dcos_url(), 'service/marathon/v2/apps')) error = exec_info.value assert str(error) == "You are not authorized to perform this operation"
def test_non_authenticated_user(): with shakedown.no_user(): with pytest.raises(errors.DCOSAuthenticationException) as exec_info: http.get(urljoin(shakedown.dcos_url(), 'service/marathon/v2/apps')) error = exec_info.value assert str(error) == "Authentication failed. Please run `dcos auth login`"