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