def _join_path(url, path): _url = URL(url) path = URL(path) if path.path: _url = _url.add_path(unquote_url(path.path)) if path.query: _url = _url.with_query(path.query) return _url
def __init__(self, system): object_types = (system.hosts.object_type, system.host_clusters.object_type) super(SanClients, self).__init__(URL('san_clients'), object_types, factory=self._san_client_factory, system=system)
def __init__(self, system): object_types = (system.volumes.object_type, system.filesystems.object_type) super(Datasets, self).__init__(URL('datasets'), object_types, factory=self._dataset_factory, system=system)
class FcSoftTarget(SystemObject): BINDER_CLASS = FcSoftTargetsBinder URL_PATH = URL('fc/soft_targets') FIELDS = [ Field("id", type=int, is_identity=True, cached=True), Field("wwpn", cached=True, type=WWNType), Field("port_number", type=int), Field("switch", api_name="switch_id", type="infinisdk.infinibox.fc_switch:FcSwitch", creation_parameter=True, binding=RelatedObjectBinding('fc_switches')), Field("node", api_name="node_id", binding=RelatedComponentBinding(api_index_name='node_id', value_for_none=None)), Field("is_home", type=bool, add_getter=False), ] @classmethod def is_supported(cls, system): return system.compat.has_npiv() @classmethod def get_type_name(cls): return "fc_soft_target" def is_home(self, **kwargs): return self.get_field('is_home', **kwargs)
class LDAPConfig(SystemObject): BINDER_CLASS = LDAPConfigBinder URL_PATH = URL('/api/rest/config/ldap') FIELDS = [ Field('id', type=int, is_identity=True), Field('name', mutable=True), ] @classmethod def get_plural_name(cls): return 'ldap_configs' def create_group(self, name, dn, role): """Maps a specified group in the LDAP directory to a specified role in the system """ returned = self.system.api.post('users', data={ 'name': name, 'dn': dn, 'ldap_id': self.id, 'role': role, 'type': 'Ldap' }) return User(self.system, returned.get_result()) def modify(self, **kwargs): """Modifies the LDAP configuration """ post_dict = {} for key, value in iteritems(kwargs): if key.startswith('schema_'): post_dict.setdefault('schema_definition', {})[key.split('_', 1)[1]] = value else: post_dict[key] = value self.system.api.put('config/ldap/{}'.format(self.id), data=post_dict) def test(self): """Tests the LDAP configuration """ self.system.api.post('config/ldap/{}/test'.format(self.id), data={}) @deprecated("Use create_group instead", since='54.0') def create_local_group(self, name, role, dn): returned = self.system.api.post('users', data={ 'type': 'Ldap', 'name': name, 'roles': [ role, ], 'dn': dn, 'ldap_id': self.id, }) return self.system.users.get_by_id_lazy( returned.get_json()['result']['id'])
def __init__(self, system, request_kwargs, err, api_request, start_timestamp): super(APITransportFailure, self).__init__('APITransportFailure: {}'.format(err)) self.start_timestamp = start_timestamp self.err = err self.api_request = api_request self.system = system self.address = URL(api_request.url).hostname self.attrs = munchify(request_kwargs) self.error_desc = str(err)
def url(request, flask_app): address = str(uuid1()) returned = URL('http://{0}'.format(address)) webapp = FlaskLoopback(flask_app) webapp.activate_address((address, 80)) @request.addfinalizer def finalize(): # pylint: disable=unused-variable webapp.deactivate_address((address, 80)) return returned
def mailboxer_url(request, db_engine): loopback = FlaskLoopback(create_app()) hostname = str(uuid.uuid1()) loopback.activate_address((hostname, 80)) @request.addfinalizer def close(): loopback.deactivate_address((hostname, 80)) return URL("http://{0}".format(hostname))
def fetch_token(self, username, password): url = URL(self._get_backslash_url()) with requests.Session() as s: resp = s.get(self._get_token_request_url()) resp.raise_for_status() response_url = resp.json()['url'] request_id = response_url.split('/')[-1] s.post(url.add_path('login'), data=json.dumps({'username': username, 'password': password}), headers={'Content-type': 'application/json'})\ .raise_for_status() s.post(URL(self._get_backslash_url()).add_path('/runtoken/request/{}/complete'.format(request_id)))\ .raise_for_status() resp = s.get(response_url) resp.raise_for_status() returned = self._runtoken = resp.json()['token'] return returned
def __init__(self, resp, data, start_timestamp, end_timestamp): super(Response, self).__init__() self.method = resp.request.method #: Response object as returned from ``requests`` self.response = resp #: The URL from which this response was obtained self.url = URL(resp.request.url) #: Data sent to on self.sent_data = data self._cached_json = NOTHING self.start_time = start_timestamp self.end_time = end_timestamp
def __init__(self, client, url, runtoken): super(API, self).__init__() self.client = client self.url = URL(url) self.runtoken = runtoken self.session = requests.Session() self.session.headers.update({ 'X-Backslash-run-token': self.runtoken, 'X-Backslash-client-version': BACKSLASH_CLIENT_VERSION, }) self.call = CallProxy(self) self._cached_info = None
def downloaded(self, urlstr, path=None): """ We say that a remote file has been 'downloaded' to a local directory if we can spot the SHA1 of its URL inside exactly one local filename. """ path = self.path(path or '') oneornone = filter(lambda fn: fn.find(URL(urlstr).hash) > -1, self.listdir(path)[-1]) if len(oneornone) is 1: one = oneornone[0] return bool(self.size(one)) and self.path(one) or None return None
def ref_from_url(url): url = URL(url) query = url.query.dict.get(QUERY_PARAM, '') page = url.query.dict.get(PAGE_PARAM, 1) filters = get_filters(url.query.multi_dict.get) locale = translation.get_language() md5 = hashlib.md5() for value in [query, page, locale] + filters: md5.update(smart_str(value)) return md5.hexdigest()[:16]
def ref_from_url(url): url = URL(url) query = url.query.dict.get(QUERY_PARAM, '') page = url.query.dict.get(PAGE_PARAM, 1) topics = url.query.multi_dict.get(TOPICS_PARAM, []) locale = translation.get_language() md5 = hashlib.md5() for value in [query, page, locale] + topics: md5.update(unicode(value)) return md5.hexdigest()[:16]
class NotificationTarget(SystemObject): URL_PATH = URL('/api/rest/notifications/targets') FIELDS = [ Field('id', type=int, is_identity=True), Field('name', creation_parameter=True, mutable=True, default=Autogenerate("target_{uuid}")), Field('protocol'), #### SMTP ##### Field('tls', type=bool, mutable=True), Field('host', mutable=True), Field('port', type=int, mutable=True), Field('from_address', mutable=True), Field('username', mutable=True), Field('password', mutable=True), Field('visibility', mutable=True), #### SNMP #### Field('version', type=str, mutable=True), Field('auth_protocol', mutable=True), Field('auth_type', mutable=True), Field('community', mutable=True), Field('engine', mutable=True), Field('private_key', mutable=True), Field('private_protocol', mutable=True), #### Syslog #### Field('transport', mutable=True), Field('facility', mutable=True), ] @classmethod def get_plural_name(cls): return 'notification_targets' def test(self, recipients=None): """Tests the SMTP gateway, by sending a test email to one or several recipients :param recipients: Either a single email or a list of emails to send to (only for SMTP) """ data = {} if recipients is not None: if not isinstance(recipients, list): recipients = [recipients] data['recipients'] = recipients return self.system.api.post('notifications/targets/{}/test'.format( self.id), data=data)
def __init__(self, response): super(APICommandFailed, self).__init__(response) self.response = response self.status_code = self.response.response.status_code json = response.get_json() error = response.get_error() self.error_code = error.get('code') if error else None if json is None: message = "[{}]".format(response.response.content) else: message = (json.get("error") or {}).get("message", "?") self.reasons = self._parse_reasons(error or {}) self.message = message self.address = URL(response.response.request.url).hostname
def _get_runtoken_request_status(request_id): request_key = 'request:{}'.format(request_id) value = get_redis_client().get(request_key) if value is None: abort(requests.codes.not_found) # pylint: disable=no-member return jsonify({ 'token': value.decode('utf-8'), 'url': URL(request.host_url).add_path( url_for('runtoken.runtoken_request', request_id=request_id)), 'complete': request.host_url + '#/runtoken/' + request_id + '/authorize', })
def referrer_url(request): referrer = request.META.get('HTTP_REFERER', None) # Non-ASCII referers can be problematic. # TODO: The 'ftfy' library can probably fix these, but may not be # worth the effort. try: urlpath = URL(referrer).path except UnicodeDecodeError: urlpath = None if (referrer is None or urlpath is None or reverse('search', locale=request.locale) != urlpath): return None return referrer
def extend_url(self, *predicates, **kw): assert self._mutable, "Cannot modify query after fetching" url = URL(self.query) if kw: predicates = itertools.chain( predicates, (self._get_or_fabricate_field(key) == value for key, value in kw.items())) for pred in predicates: if isinstance(pred.field, QField): pred = FieldFilter( self._get_or_fabricate_field(pred.field.name), pred.operator_name, pred.value) url = pred.add_to_url(url, self.system) self.query = url return self
def add_comma_separated_query_param(url, param_name, value): """ >>> str(add_comma_separated_query_param("http://a.com/a/b/c", "sort", "a")) 'http://a.com/a/b/c?sort=a' >>> str(add_comma_separated_query_param("http://a.com/a/b/c?sort=a", "sort", "b")) 'http://a.com/a/b/c?sort=a%2Cb' >>> str(add_comma_separated_query_param("http://a.com/a/b/c", "sort", ("a", "b"))) 'http://a.com/a/b/c?sort=a%2Cb' """ if not isinstance(url, URL): url = URL(url) if isinstance(value, Iterable) and not isinstance(value, string_types): value = ",".join(value) existing_sort = url.query_dict.get(param_name, "") if existing_sort: existing_sort = "{},".format(existing_sort) return url.set_query_param(param_name, "{}{}".format(existing_sort, value))
def ref_from_url(url): url = URL(url) md5 = hashlib.md5() try: query = url.query.dict.get(QUERY_PARAM, '') page = url.query.dict.get(PAGE_PARAM, 1) filters = get_filters(url.query.multi_dict.get) except UnicodeDecodeError: query = '' page = 1 filters = [] locale = translation.get_language() for value in [query, page, locale] + filters: md5.update(smart_bytes(value)) return md5.hexdigest()[:16]
def _fake_requests_send(self, request, **kwargs): url = URL(request.url) address = (url.hostname, url.port or url.default_port) handler, ssl = _registered_addresses.get(address, (None, None)) if handler is None: return _orig_session_send(self, request, **kwargs) request_is_ssl = url.scheme == "https" if request_is_ssl and not ssl: if SSLError is None: raise NotImplementedError() # pragma: no cover raise SSLError() if not request_is_ssl and ssl: raise requests.ConnectionError() return handler.handle_request(self, url, request)
class NotificationRule(SystemObject): URL_PATH = URL('/api/rest/notifications/rules') FIELDS = [ Field('id', type=int, is_identity=True), Field('name', mutable=True, creation_parameter=True, default=Autogenerate("rule_{uuid}")), Field('event_code', type=str, mutable=True), Field('event_level', type=list, mutable=True), Field('target_parameters', type=dict, mutable=True), Field('target', api_name='target_id', mutable=True, creation_parameter=True, binding=RelatedObjectBinding('notification_targets')), Field('include_events', type=list, mutable=True), Field('exclude_events', type=list, mutable=True), Field('event_visibility', type=list), ] @classmethod def get_type_name(cls): return 'notification_rule'
def get_search_url_from_referer(request): """Returns search url from referer if it was an MDN search""" # Note: "HTTP_REFERER" is spelled wrong in the spec and we use "referer" # here to mirror that. referer = request.META.get('HTTP_REFERER', None) # Non-ASCII referers can be problematic. # TODO: The 'ftfy' library can probably fix these, but may not be # worth the effort. try: url = URL(referer) except UnicodeDecodeError: url = None current_site = Site.objects.get_current() # The referer url must be an MDN search--if not, then we return None. # We verify the protocol, host and path. if (referer is None or url is None or url.scheme != 'https' or url.netloc != current_site.domain or reverse('search', locale=request.LANGUAGE_CODE) != url.path): return None return referer
def download(self, urlstr, **kwargs): """ Call url_rs.download('URL') to save that URL's contents into a new file within the storages' filesystem. Optionally setting the 'clobber' keyword to False will raise an exception before overwriting existing data. Any other keyword args are passed wholesale to URLRequestFile's constructor when the new file is saved locally. """ import requests import socket url = URL(urlstr) clobber = bool(kwargs.pop('clobber', True)) try: headstat = requests.head(url) except (requests.exceptions.TooManyRedirects, requests.exceptions.ConnectionError, requests.exceptions.SSLError, requests.exceptions.Timeout, socket.gaierror, socket.herror, socket.sslerror, socket.timeout), err: print("*** HTTP HEAD failed for %s" % url, file=sys.stderr) print("--- (%s)" % err, file=sys.stderr) return None
def __init__(self, app): super(Webapp, self).__init__() self.app = app self.loopback = FlaskLoopback(self.app) self.hostname = str(uuid4()) self.url = URL('http://{0}'.format(self.hostname))
def _url(address): return URL("http://{0}:{1}/".format(*address))
def deployment_webapp_url(request): port = request.config.getoption("--www-port") return URL("http://127.0.0.1").with_port(port)
def calculate_reclaimable_space(self, entities): url = URL(self.object_type.get_url_path( self.system)).add_path('delete_simulation') res = self.system.api.post( url, data=dict(entities=[entity.id for entity in entities])) return res.get_result()['space_reclaimable'] * byte
def calculate_reclaimable_space(self): url = URL(self.get_url_path(self.system)).add_path('delete_simulation') res = self.system.api.post(url, data=dict(entities=[self.id])) return res.get_result()['space_reclaimable'] * byte