def urlparams(url_, fragment=None, query_dict=None, **query):
"""
Add a fragment and/or query parameters to a URL.
New query params will be appended to exising parameters, except duplicate
names, which will be replaced.
"""
url_ = urlparse(url_)
fragment = fragment if fragment is not None else url_.fragment
q = url_.query
new_query_dict = (QueryDict(smart_bytes(q), mutable=True) if
q else QueryDict('', mutable=True))
if query_dict:
for k, l in query_dict.lists():
new_query_dict[k] = None # Replace, don't append.
for v in l:
new_query_dict.appendlist(k, v)
for k, v in query.items():
# Replace, don't append.
if isinstance(v, list):
new_query_dict.setlist(k, v)
else:
new_query_dict[k] = v
query_string = urlencode([(k, v) for k, l in new_query_dict.lists() for
v in l if v is not None])
new = ParseResult(url_.scheme, url_.netloc, url_.path, url_.params, query_string, fragment)
return new.geturl()
def urlparams(url_, fragment=None, query_dict=None, **query):
"""
Add a fragment and/or query parameters to a URL.
New query params will be appended to exising parameters, except duplicate
names, which will be replaced.
"""
url_ = urlparse(url_)
fragment = fragment if fragment is not None else url_.fragment
q = url_.query
new_query_dict = (QueryDict(smart_bytes(q), mutable=True)
if q else QueryDict('', mutable=True))
if query_dict:
for k, l in query_dict.lists():
new_query_dict[k] = None # Replace, don't append.
for v in l:
new_query_dict.appendlist(k, v)
for k, v in query.items():
# Replace, don't append.
if isinstance(v, list):
new_query_dict.setlist(k, v)
else:
new_query_dict[k] = v
query_string = urlencode([(k, v) for k, l in new_query_dict.lists()
for v in l if v is not None])
new = ParseResult(url_.scheme, url_.netloc, url_.path, url_.params,
query_string, fragment)
return new.geturl()
def get_couch_controller_or_bust(db_name):
"""
Get :py:class:`djali.couchdb.CloudiControl` instance for given database.
Args:
db_name: Database name
Returns:
djali.couchdb.CloudiControl: controller instance
Raises:
werkzeug.exceptions.HTTPException: When controller cannot be instanciated
"""
p_url = urlparse(storage_backend)
couch_db_pr = ParseResult(p_url.scheme, p_url.netloc,
'/{db_name}'.format(db_name=db_name), '', '', '')
db_url = couch_db_pr.geturl()
try:
return CloudiControl(db_url)
except requests.exceptions.HTTPError as hexc:
app.logger.error(
"Cloudi error while trying to use {!r}".format(db_url))
app.logger.error(hexc)
if hexc.response.status_code == 403:
abort(502)
abort(503)
except requests.exceptions.ConnectionError as cexc:
app.logger.error(
"Cloudi error while trying to use {!r}".format(db_url))
app.logger.error(cexc)
abort(503)
def clean_url(url):
"""
Remove params, query and fragment parts from URL so that `os.path.basename`
and `os.path.splitext` can work correctly.
@param url: URL to clean.
@type url: str
@return: Cleaned URL.
@rtype: str
"""
parsed = urlparse(url.strip())
reconstructed = ParseResult(
parsed.scheme, parsed.netloc, parsed.path,
params='', query='', fragment='')
return reconstructed.geturl()
def handle_authcode(request, client, redirection_uri, state=None):
parts = urlparse(redirection_uri.uri)
qparams = dict(parse_qsl(parts.query))
user_id = authenticated_userid(request)
auth_code = Oauth2Code(client, user_id)
db.add(auth_code)
db.flush()
qparams['code'] = auth_code.authcode
if state:
qparams['state'] = state
parts = ParseResult(parts.scheme, parts.netloc, parts.path, parts.params,
urlencode(qparams), '')
return HTTPFound(location=parts.geturl())
def handle_authcode(request, client, redirection_uri, state=None):
parts = urlparse(redirection_uri.uri)
qparams = dict(parse_qsl(parts.query))
user_id = authenticated_userid(request)
auth_code = Oauth2Code(client, user_id)
db.add(auth_code)
db.flush()
qparams['code'] = auth_code.authcode
if state:
qparams['state'] = state
parts = ParseResult(
parts.scheme, parts.netloc, parts.path, parts.params,
urlencode(qparams), '')
return HTTPFound(location=parts.geturl())
def clean_url(url):
"""
Remove params, query and fragment parts from URL so that `os.path.basename`
and `os.path.splitext` can work correctly.
@param url: URL to clean.
@type url: str
@return: Cleaned URL.
@rtype: str
"""
parsed = urlparse(url.strip())
reconstructed = ParseResult(
parsed.scheme, parsed.netloc, parsed.path,
params='', query='', fragment='')
return reconstructed.geturl()
def validate(self, instance, value):
"""Check if input is valid URL"""
value = super(URL, self).validate(instance, value)
parsed_url = urlparse(value)
if not parsed_url.scheme or not parsed_url.netloc:
self.error(instance, value, extra='URL needs scheme and netloc.')
parse_result = ParseResult(
scheme=parsed_url.scheme,
netloc=parsed_url.netloc,
path=parsed_url.path,
params='' if self.remove_parameters else parsed_url.params,
query='' if self.remove_parameters else parsed_url.query,
fragment='' if self.remove_fragment else parsed_url.fragment,
)
parse_result = parse_result.geturl()
return parse_result
def validate(self, instance, value):
"""Check if input is valid URL"""
value = super(URL, self).validate(instance, value)
parsed_url = urlparse(value)
if not parsed_url.scheme or not parsed_url.netloc:
self.error(instance, value, extra='URL needs scheme and netloc.')
parse_result = ParseResult(
scheme=parsed_url.scheme,
netloc=parsed_url.netloc,
path=parsed_url.path,
params='' if self.remove_parameters else parsed_url.params,
query='' if self.remove_parameters else parsed_url.query,
fragment='' if self.remove_fragment else parsed_url.fragment,
)
parse_result = parse_result.geturl()
return parse_result
def force_https(url):
"""Force ``url`` to use https as its scheme.
Parameters:
url: str
A string representation of a URL.
Returns:
str
``url`` with its scheme replaced with https.
Throws:
Any potential error thrown by the urlparse function during parsing.
"""
parsed = urlparse(url)
with_https = ParseResult("https", *parsed[1:])
return with_https.geturl()
def __init__(self, instance_url, *args, **kwargs):
self.log = kwargs.get("use_log", logging.getLogger(__name__))
p_url = urlparse(instance_url)
self._scheme = p_url.scheme
self._netloc = p_url.netloc
if '@' in p_url.netloc:
self._netloc = p_url.netloc.split('@')[1]
username = ''
password = ''
if p_url.username is not None:
username = p_url.username
if p_url.password is not None:
password = p_url.password
self._root_auth = (username, password)
couch_db_pr = ParseResult(self._scheme, self._netloc, '', '', '', '')
self.instance_url = couch_db_pr.geturl()
def __init__(self, *args, **kwargs):
self.client = None
username = COUCHDB_USERNAME
password = COUCHDB_PASSWORD
db_name = COUCHDB_DB_NAME
couch_db_url = None
if kwargs.get("use_log"):
self.log = kwargs['use_log']
else:
self.log = logging.getLogger(__name__)
if args:
p_url = urlparse(args[0])
if p_url.username is not None:
username = p_url.username
if p_url.password is not None:
password = p_url.password
if p_url.path:
split_path = p_url.path.split("/", 2)
try:
db_name = split_path[1]
except IndexError:
db_name = split_path[0]
if p_url.scheme:
couch_db_pr = ParseResult(p_url.scheme, p_url.netloc, '', '',
'', '')
couch_db_url = couch_db_pr.geturl()
if couch_db_url is None:
default_p = urlparse(COUCHDB_URL)
auth_prefix_parts = list()
username = kwargs.get("username", COUCHDB_USERNAME)
password = kwargs.get("password", COUCHDB_PASSWORD)
scheme = kwargs.get("scheme", default_p.scheme)
port = kwargs.get("port", default_p.port)
host = kwargs.get("host", default_p.hostname)
if not port:
port = 5984
if scheme == 'https':
port = 6984
if username:
auth_prefix_parts.append(username)
if password:
auth_prefix_parts.append(':')
auth_prefix_parts.append(password)
if len(auth_prefix_parts) > 0:
auth_prefix_parts.append('@')
netloc = "{auth_prefix}{host:s}:{port:d}".format(
auth_prefix=''.join(auth_prefix_parts),
host=host,
port=int(port))
couch_db_url = ParseResult(scheme, netloc, "", "", "", "").geturl()
if couch_db_url is None:
couch_db_url = COUCHDB_URL
self._auth = (username, password)
self._couch_db_url = couch_db_url
self._storage_db = db_name
self._connect()
if kwargs.get("create"):
try:
self.database
except KeyError:
self.client.create_database(self._storage_db)
