def _setup_firewall(self, ri, fw):
client = self._get_vyatta_client(ri.router)
fw_cmd_list = []
# Create firewall
fw_name = vyatta_utils.get_firewall_name(ri, fw)
fw_cmd_list.append(
vyatta_client.SetCmd(
FW_NAME.format(parse.quote_plus(fw_name))))
if fw.get('description'):
fw_cmd_list.append(vyatta_client.SetCmd(
FW_DESCRIPTION.format(
parse.quote_plus(fw_name),
parse.quote_plus(fw['description']))))
# Set firewall state policy
fw_cmd_list.append(vyatta_client.SetCmd(FW_ESTABLISHED_ACCEPT))
fw_cmd_list.append(vyatta_client.SetCmd(FW_RELATED_ACCEPT))
# Create firewall rules
rule_num = 0
for rule in fw['firewall_rule_list']:
if not rule['enabled']:
continue
if rule['ip_version'] == 4:
rule_num += 1
fw_cmd_list += self._set_firewall_rule(fw_name, rule_num, rule)
else:
LOG.warn(_LW("IPv6 rules are not supported."))
# Configure router zones
zone_cmd_list = vyatta_utils.get_zone_cmds(client, ri, fw_name)
client.exec_cmd_batch(fw_cmd_list + zone_cmd_list)
def _setup_optimizer(self, ri, opt):
client = self._get_vyatta_client(ri.router)
opt_cmd_list = []
# Create optimizer
opt_name = vyatta_utils.get_optimizer_name(ri, opt)
opt_cmd_list.append(
vyatta_client.SetCmd(
FW_NAME.format(parse.quote_plus(opt_name))))
if opt.get('description'):
opt_cmd_list.append(vyatta_client.SetCmd(
FW_DESCRIPTION.format(
parse.quote_plus(opt_name),
parse.quote_plus(opt['description']))))
# Set optimizer state policy
opt_cmd_list.append(vyatta_client.SetCmd(FW_ESTABLISHED_ACCEPT))
opt_cmd_list.append(vyatta_client.SetCmd(FW_RELATED_ACCEPT))
# Create optimizer rules
rule_num = 0
for rule in opt['optimizer_rule_list']:
if not rule['enabled']:
continue
if rule['ip_version'] == 4:
rule_num += 1
opt_cmd_list += self._set_optimizer_rule(opt_name, rule_num, rule)
else:
LOG.warn(_LW("IPv6 rules are not supported."))
# Configure router zones
zone_cmd_list = vyatta_utils.get_zone_cmds(client, ri, opt_name)
client.exec_cmd_batch(opt_cmd_list + zone_cmd_list)
def get_raw_yaml_from_repo(repo, full_name, commit_sha):
# type: (Repo_ish, Text, bytes) -> Any
"""Return decoded YAML data structure from
the given file in *repo* at *commit_sha*.
:arg commit_sha: A byte string containing the commit hash
"""
from six.moves.urllib.parse import quote_plus
cache_key = "%RAW%%2".join((
CACHE_KEY_ROOT,
quote_plus(repo.controldir()), quote_plus(full_name), commit_sha.decode(),
))
import django.core.cache as cache
def_cache = cache.caches["default"]
result = None # type: Optional[Any]
# Memcache is apparently limited to 250 characters.
if len(cache_key) < 240:
result = def_cache.get(cache_key)
if result is not None:
return result
yaml_str = expand_yaml_macros(
repo, commit_sha,
get_repo_blob(repo, full_name, commit_sha,
allow_tree=False).data)
result = load_yaml(yaml_str) # type: ignore
def_cache.add(cache_key, result, None)
return result
def test_get_console_url(self, mock_get):
token = "abcdefg123"
callbackurl = ""
mock_get.return_value = Mock(text=u'{"SigninToken": "%s"}' % token,
status_code=200,
reason="Ok")
url_template = ("https://signin.aws.amazon.com/federation?"
"Action=login&"
"Issuer={callbackurl}&"
"Destination=https%3A%2F%2Fconsole.aws.amazon.com%2F&"
"SigninToken={token}")
expected_url = url_template.format(callbackurl=quote_plus(callbackurl),
token=token).encode()
result = self.app.get('/account/testaccount/testrole/consoleurl')
self.assertEqual(result.status_int, 200)
self.assertEqual(result.body, expected_url)
# Check if the Callback URL is set
callbackurl = "https://www.foobar.invalid"
expected_url = url_template.format(callbackurl=quote_plus(callbackurl),
token=token).encode()
result = self.app.get('/account/testaccount/testrole/consoleurl',
{'callbackurl': callbackurl})
self.assertEqual(result.status_int, 200)
self.assertEqual(result.body, expected_url)
def get_raw_yaml_from_repo(repo, full_name, commit_sha):
"""Return decoded YAML data structure from
the given file in *repo* at *commit_sha*.
:arg commit_sha: A byte string containing the commit hash
"""
from six.moves.urllib.parse import quote_plus
cache_key = "%RAW%%2".join((
quote_plus(repo.controldir()), quote_plus(full_name), commit_sha.decode()))
import django.core.cache as cache
def_cache = cache.caches["default"]
result = None
# Memcache is apparently limited to 250 characters.
if len(cache_key) < 240:
result = def_cache.get(cache_key)
if result is not None:
return result
result = load_yaml(
expand_yaml_macros(
repo, commit_sha,
get_repo_blob(repo, full_name, commit_sha).data))
def_cache.add(cache_key, result, None)
return result
def tribler_urlencode_single(key, value):
utf8_key = quote_plus(text_type(key).encode('utf-8'))
# Convert bool values to ints
if isinstance(value, bool):
value = int(value)
utf8_value = quote_plus(text_type(value).encode('utf-8'))
return "%s=%s" % (utf8_key, utf8_value)
def get_yaml_from_repo(repo, full_name, commit_sha, cached=True):
"""Return decoded, struct-ified YAML data structure from
the given file in *repo* at *commit_sha*.
See :class:`relate.utils.Struct` for more on
struct-ification.
"""
if cached:
from six.moves.urllib.parse import quote_plus
cache_key = "%%%2".join(
(quote_plus(repo.controldir()), quote_plus(full_name),
commit_sha.decode()))
import django.core.cache as cache
def_cache = cache.caches["default"]
result = None
# Memcache is apparently limited to 250 characters.
if len(cache_key) < 240:
result = def_cache.get(cache_key)
if result is not None:
return result
expanded = expand_yaml_macros(
repo, commit_sha,
get_repo_blob(repo, full_name, commit_sha).data)
result = dict_to_struct(load_yaml(expanded))
if cached:
def_cache.add(cache_key, result, None)
return result
def _process_repo(repo, runtime_storage_inst, record_processor_inst, rcs_inst):
uri = repo["uri"]
LOG.info("Processing repo uri: %s", uri)
LOG.debug("Processing blueprints for repo uri: %s", uri)
bp_iterator = lp.log(repo)
bp_iterator_typed = _record_typer(bp_iterator, "bp")
processed_bp_iterator = record_processor_inst.process(bp_iterator_typed)
runtime_storage_inst.set_records(processed_bp_iterator, utils.merge_records)
LOG.debug("Processing bugs for repo uri: %s", uri)
current_date = utils.date_to_timestamp("now")
bug_modified_since = runtime_storage_inst.get_by_key("bug_modified_since-%s" % repo["module"])
bug_iterator = bps.log(repo, bug_modified_since)
bug_iterator_typed = _record_typer(bug_iterator, "bug")
processed_bug_iterator = record_processor_inst.process(bug_iterator_typed)
runtime_storage_inst.set_records(processed_bug_iterator, utils.merge_records)
runtime_storage_inst.set_by_key("bug_modified_since-%s" % repo["module"], current_date)
vcs_inst = vcs.get_vcs(repo, cfg.CONF.sources_root)
vcs_inst.fetch()
branches = {repo.get("default_branch", "master")}
for release in repo.get("releases"):
if "branch" in release:
branches.add(release["branch"])
for branch in branches:
LOG.debug("Processing commits in repo: %s, branch: %s", uri, branch)
vcs_key = "vcs:" + str(parse.quote_plus(uri) + ":" + branch)
last_id = runtime_storage_inst.get_by_key(vcs_key)
commit_iterator = vcs_inst.log(branch, last_id)
commit_iterator_typed = _record_typer(commit_iterator, "commit")
processed_commit_iterator = record_processor_inst.process(commit_iterator_typed)
runtime_storage_inst.set_records(processed_commit_iterator, _merge_commits)
last_id = vcs_inst.get_last_id(branch)
runtime_storage_inst.set_by_key(vcs_key, last_id)
LOG.debug("Processing reviews for repo: %s, branch: %s", uri, branch)
rcs_key = "rcs:" + str(parse.quote_plus(uri) + ":" + branch)
last_id = runtime_storage_inst.get_by_key(rcs_key)
review_iterator = rcs_inst.log(repo, branch, last_id, grab_comments=("ci" in repo))
review_iterator_typed = _record_typer(review_iterator, "review")
if "ci" in repo: # add external CI data
review_iterator_typed = _process_reviews(review_iterator_typed, repo["ci"], repo["module"], branch)
processed_review_iterator = record_processor_inst.process(review_iterator_typed)
runtime_storage_inst.set_records(processed_review_iterator, utils.merge_records)
last_id = rcs_inst.get_last_id(repo, branch)
runtime_storage_inst.set_by_key(rcs_key, last_id)
def url_quote_plus(v, name='(Unknown name)', md={}):
if six.PY2 and isinstance(v, unicode):
# quote_plus does not handle unicode. Encoding to a "safe"
# intermediate encoding before quoting, then unencoding the result.
return quote_plus(v.encode('utf-8')).decode('utf-8')
elif six.PY3 and isinstance(v, bytes):
return quote_plus(v.decode('utf-8')).encode('utf-8')
return quote_plus(str(v))
def encode_uri(uri):
split = list(urlsplit(uri))
split[1] = split[1].encode('idna').decode('ascii')
split[2] = quote_plus(split[2].encode('utf-8'), '/').decode('ascii')
query = list((q, quote_plus(v.encode('utf-8')))
for (q, v) in parse_qsl(split[3]))
split[3] = urlencode(query).decode('ascii')
return urlunsplit(split)
def _generate_connection_uri(self):
if self.use_proxy:
if self.sql_proxy_use_tcp:
if not self.sql_proxy_tcp_port:
self.reserve_free_tcp_port()
if not self.sql_proxy_unique_path:
self.sql_proxy_unique_path = self._generate_unique_path()
database_uris = CONNECTION_URIS[self.database_type]
ssl_spec = None
socket_path = None
if self.use_proxy:
proxy_uris = database_uris['proxy']
if self.sql_proxy_use_tcp:
format_string = proxy_uris['tcp']
else:
format_string = proxy_uris['socket']
socket_path = \
"{sql_proxy_socket_path}/{instance_socket_name}".format(
sql_proxy_socket_path=self.sql_proxy_unique_path,
instance_socket_name=self._get_instance_socket_name()
)
else:
public_uris = database_uris['public']
if self.use_ssl:
format_string = public_uris['ssl']
ssl_spec = {
'cert': self.sslcert,
'key': self.sslkey,
'ca': self.sslrootcert
}
else:
format_string = public_uris['non-ssl']
if not self.user:
raise AirflowException("The login parameter needs to be set in connection")
if not self.public_ip:
raise AirflowException("The location parameter needs to be set in connection")
if not self.password:
raise AirflowException("The password parameter needs to be set in connection")
if not self.database:
raise AirflowException("The database parameter needs to be set in connection")
connection_uri = format_string.format(
user=quote_plus(self.user) if self.user else '',
password=quote_plus(self.password) if self.password else '',
database=quote_plus(self.database) if self.database else '',
public_ip=self.public_ip,
public_port=self.public_port,
proxy_port=self.sql_proxy_tcp_port,
socket_path=self._quote(socket_path),
ssl_spec=self._quote(json.dumps(ssl_spec)) if ssl_spec else '',
client_cert_file=self._quote(self.sslcert) if self.sslcert else '',
client_key_file=self._quote(self.sslkey) if self.sslcert else '',
server_ca_file=self._quote(self.sslrootcert if self.sslcert else '')
)
self.log.info("DB connection URI %s", connection_uri.replace(
quote_plus(self.password) if self.password else 'PASSWORD', 'XXXXXXXXXXXX'))
return connection_uri
def to_query(object, key=None):
""" Dumps a dictionary into a nested query string."""
object_type = type(object)
if object_type is dict:
return '&'.join([to_query(object[k], '%s[%s]' % (key, k) if key else k) for k in sorted(object)])
elif object_type in (list, tuple):
return '&'.join([to_query(o, '%s[]' % key) for o in object])
else:
return '%s=%s' % (quote_plus(str(key)), quote_plus(str(object)))
def get_display_url(self, data, trans):
dataset_hash, user_hash = encode_dataset_user(trans, data, None)
return url_for(controller='dataset',
action="display_application",
dataset_id=dataset_hash,
user_id=user_hash,
app_name=quote_plus(self.display_application.id),
link_name=quote_plus(self.id),
app_action=None)
def get_repo_blob_data_cached(repo, full_name, commit_sha):
# type: (Repo_ish, Text, bytes) -> bytes
"""
:arg commit_sha: A byte string containing the commit hash
"""
if isinstance(commit_sha, six.binary_type):
from six.moves.urllib.parse import quote_plus
cache_key = "%s%R%1".join((
CACHE_KEY_ROOT,
quote_plus(repo.controldir()),
quote_plus(full_name),
commit_sha.decode(),
".".join(str(s) for s in sys.version_info[:2]),
)) # type: Optional[Text]
else:
cache_key = None
try:
import django.core.cache as cache
except ImproperlyConfigured:
cache_key = None
result = None # type: Optional[bytes]
if cache_key is None:
result = get_repo_blob(repo, full_name, commit_sha,
allow_tree=False).data
assert isinstance(result, six.binary_type)
return result
# Byte string is wrapped in a tuple to force pickling because memcache's
# python wrapper appears to auto-decode/encode string values, thus trying
# to decode our byte strings. Grr.
def_cache = cache.caches["default"]
# Memcache is apparently limited to 250 characters.
if len(cache_key) < 240:
cached_result = def_cache.get(cache_key)
if cached_result is not None:
(result,) = cached_result
assert isinstance(result, six.binary_type), cache_key
return result
result = get_repo_blob(repo, full_name, commit_sha,
allow_tree=False).data
assert result is not None
if len(result) <= getattr(settings, "RELATE_CACHE_MAX_BYTES", 0):
def_cache.add(cache_key, (result,), None)
assert isinstance(result, six.binary_type)
return result
def get_repo_keys(memcached_inst):
for repo in (memcached_inst.get('repos') or []):
uri = repo['uri']
branches = set(['master'])
for release in repo.get('releases'):
if 'branch' in release:
branches.add(release['branch'])
for branch in branches:
yield 'vcs:' + str(parse.quote_plus(uri) + ':' + branch)
yield 'rcs:' + str(parse.quote_plus(uri) + ':' + branch)
def test_oauth2_get_authorize_url_native():
"""
Starts an auth flow with a NativeAppFlowManager, gets the authorize url
validates expected results with both default and specified parameters.
"""
ac = globus_sdk.AuthClient(client_id=CLIENT_ID)
# default parameters for starting auth flow
flow_manager = globus_sdk.auth.GlobusNativeAppFlowManager(ac)
ac.current_oauth2_flow_manager = flow_manager
# get url_and validate results
url_res = ac.oauth2_get_authorize_url()
expected_vals = [
ac.base_url + "v2/oauth2/authorize?",
"client_id=" + ac.client_id,
"redirect_uri=" + quote_plus(ac.base_url + "v2/web/auth-code"),
"scope=" + quote_plus(" ".join(DEFAULT_REQUESTED_SCOPES)),
"state=" + "_default",
"response_type=" + "code",
"code_challenge=" + quote_plus(flow_manager.challenge),
"code_challenge_method=" + "S256",
"access_type=" + "online",
]
for val in expected_vals:
assert val in url_res
# starting flow with specified paramaters
flow_manager = globus_sdk.auth.GlobusNativeAppFlowManager(
ac,
requested_scopes="scopes",
redirect_uri="uri",
state="state",
verifier=("a" * 43),
refresh_tokens=True,
)
ac.current_oauth2_flow_manager = flow_manager
# get url_and validate results
url_res = ac.oauth2_get_authorize_url()
verifier, remade_challenge = make_native_app_challenge("a" * 43)
expected_vals = [
ac.base_url + "v2/oauth2/authorize?",
"client_id=" + ac.client_id,
"redirect_uri=" + "uri",
"scope=" + "scopes",
"state=" + "state",
"response_type=" + "code",
"code_challenge=" + quote_plus(remade_challenge),
"code_challenge_method=" + "S256",
"access_type=" + "offline",
]
for val in expected_vals:
assert val in url_res
def process_repo(repo, runtime_storage_inst, record_processor_inst):
uri = repo['uri']
LOG.debug('Processing repo uri %s' % uri)
bp_iterator = lp.log(repo)
bp_iterator_typed = _record_typer(bp_iterator, 'bp')
processed_bp_iterator = record_processor_inst.process(
bp_iterator_typed)
runtime_storage_inst.set_records(processed_bp_iterator,
utils.merge_records)
vcs_inst = vcs.get_vcs(repo, cfg.CONF.sources_root)
vcs_inst.fetch()
rcs_inst = rcs.get_rcs(repo, cfg.CONF.review_uri)
rcs_inst.setup(key_filename=cfg.CONF.ssh_key_filename,
username=cfg.CONF.ssh_username)
branches = set(['master'])
for release in repo.get('releases'):
if 'branch' in release:
branches.add(release['branch'])
for branch in branches:
LOG.debug('Processing repo %s, branch %s', uri, branch)
vcs_key = 'vcs:' + str(parse.quote_plus(uri) + ':' + branch)
last_id = runtime_storage_inst.get_by_key(vcs_key)
commit_iterator = vcs_inst.log(branch, last_id)
commit_iterator_typed = _record_typer(commit_iterator, 'commit')
processed_commit_iterator = record_processor_inst.process(
commit_iterator_typed)
runtime_storage_inst.set_records(
processed_commit_iterator, _merge_commits)
last_id = vcs_inst.get_last_id(branch)
runtime_storage_inst.set_by_key(vcs_key, last_id)
LOG.debug('Processing reviews for repo %s, branch %s', uri, branch)
rcs_key = 'rcs:' + str(parse.quote_plus(uri) + ':' + branch)
last_id = runtime_storage_inst.get_by_key(rcs_key)
review_iterator = rcs_inst.log(branch, last_id)
review_iterator_typed = _record_typer(review_iterator, 'review')
processed_review_iterator = record_processor_inst.process(
review_iterator_typed)
runtime_storage_inst.set_records(processed_review_iterator,
utils.merge_records)
last_id = rcs_inst.get_last_id(branch)
runtime_storage_inst.set_by_key(rcs_key, last_id)
def _get_tomahawk_url(metadata):
"""Generates URL for iframe with Tomahawk embedded player.
See http://toma.hk/tools/embeds.php for more info.
"""
if not ('artist' in metadata and 'title' in metadata):
return None
else:
return "http://toma.hk/embed.php?artist={artist}&title={title}".format(
artist=quote_plus(metadata['artist'].encode("UTF-8")),
title=quote_plus(metadata['title'].encode("UTF-8")),
)
def _alternatives(self, account, container, obj):
# put S3 parts in dedicated container
suffix = ("+segments" if container and container.endswith('+segments')
else "")
if obj is None:
yield account, container, obj
elif self.stop_at_first_match:
# TODO(FVE): when supported, also pass account to con_builder()
yield account, quote_plus(self.con_builder(obj)) + suffix, obj
else:
for alt_container in self.con_builder.alternatives(obj):
yield account, quote_plus(alt_container) + suffix, obj
raise StopIteration
def encode(self):
delimiter = '&'
pairs = []
for key, value in self.params.iterallitems():
utf8key = utf8(key, utf8(str(key)))
utf8value = utf8(value, utf8(str(value)))
quoted_key = quote_plus(utf8key, self.SAFE_KEY_CHARS)
quoted_value = quote_plus(utf8value, self.SAFE_VALUE_CHARS)
pair = '='.join([quoted_key, quoted_value])
if value is None: # Example: http://sprop.su/?param
pair = quoted_key
pairs.append(pair)
return delimiter.join(pairs)
def url(self):
base_url = self.trans.request.base
if self.parameter.strip_https and base_url[: 5].lower() == 'https':
base_url = "http%s" % base_url[5:]
return "%s%s" % (base_url,
url_for(controller='dataset',
action="display_application",
dataset_id=self._dataset_hash,
user_id=self._user_hash,
app_name=quote_plus(self.parameter.link.display_application.id),
link_name=quote_plus(self.parameter.link.id),
app_action=self.action_name,
action_param=self._url))
def _get_youtube_query(metadata):
"""Generates a query string to search youtube for this song
See https://developers.google.com/youtube/player_parameters#Manual_IFrame_Embeds
for more info.
"""
if not ('artist' in metadata and 'title' in metadata):
return None
else:
return "{artist}+{title}".format(
artist=quote_plus(metadata['artist'].encode("UTF-8")),
title=quote_plus(metadata['title'].encode("UTF-8")),
)
def get_messaging_history_errors_url(self, messaging_history_url):
url_param_tuples = [
('startdate', (self.domain_now.date() - timedelta(days=6)).strftime('%Y-%m-%d')),
('enddate', self.domain_now.date().strftime('%Y-%m-%d')),
(EventStatusFilter.slug, MessagingEvent.STATUS_ERROR),
]
for event_type, description in EventTypeFilter.options:
url_param_tuples.append((EventTypeFilter.slug, event_type))
url_param_list = ['%s=%s' % (quote_plus(name), quote_plus(value)) for name, value in url_param_tuples]
url_param_str = '&'.join(url_param_list)
return '%s?%s' % (messaging_history_url, url_param_str)
def _generate_connection_uri(self):
if self.use_proxy:
if self.sql_proxy_use_tcp:
if not self.sql_proxy_tcp_port:
self.reserve_free_tcp_port()
if not self.sql_proxy_unique_path:
self.sql_proxy_unique_path = self._generate_unique_path()
database_uris = CONNECTION_URIS[self.database_type]
ssl_spec = None
socket_path = None
if self.use_proxy:
proxy_uris = database_uris['proxy']
if self.sql_proxy_use_tcp:
format_string = proxy_uris['tcp']
else:
format_string = proxy_uris['socket']
socket_path = \
"{sql_proxy_socket_path}/{instance_socket_name}".format(
sql_proxy_socket_path=self.sql_proxy_unique_path,
instance_socket_name=self._get_instance_socket_name()
)
else:
public_uris = database_uris['public']
if self.use_ssl:
format_string = public_uris['ssl']
ssl_spec = {
'cert': self.sslcert,
'key': self.sslkey,
'ca': self.sslrootcert
}
else:
format_string = public_uris['non-ssl']
connection_uri = format_string.format(
user=quote_plus(self.user),
password=quote_plus(self.password),
database=quote_plus(self.database),
public_ip=self.public_ip,
public_port=self.public_port,
proxy_port=self.sql_proxy_tcp_port,
socket_path=self._quote(socket_path),
ssl_spec=self._quote(json.dumps(ssl_spec)) if ssl_spec else None,
client_cert_file=self._quote(self.sslcert),
client_key_file=self._quote(self.sslkey),
server_ca_file=self._quote(self.sslrootcert)
)
self.log.info("DB connection URI {}".format(connection_uri.replace(
quote_plus(self.password), 'XXXXXXXXXXXX')))
return connection_uri
def instance_url(self):
self.id = util.utf8(self.id)
extn = quote_plus(self.id)
if hasattr(self, "customer"):
self.customer = util.utf8(self.customer)
base = Customer.class_url()
owner_extn = quote_plus(self.customer)
else:
raise error.InvalidRequestError(
"Could not determine whether card_id %s is " "attached to a customer " "or a recipient." % self.id, "id"
)
return "%s/%s/cards/%s" % (base, owner_extn, extn)
def selflink(query_dict, linkmode):
"""
query_dict is a dict of all the cgi parameters
linkmode is the name of the query field to include
"""
l = ['query=' + quote_plus(linkmode)]
for i in sorted(query_dict.keys()):
v = query_dict[i]
if v is None:
continue
if not isinstance(v, list):
v = [v]
for v in v:
l.append(i + '=' + quote_plus(str(v)))
return get_cgi_name() + "?" + ('&'.join(l))
def _construct_console_url(self, signin_token, callback_url):
"""Construct and return string with URL to aws console"""
# Create URL that will let users sign in to the console using the
# sign-in token. This URL must be used within 15 minutes of when the
# sign-in token was issued.
request_url_template = (
"https://signin.aws.amazon.com/federation"
"?Action=login"
"&Issuer={callbackurl}"
"&Destination={destination}"
"&SigninToken={signin_token}")
return request_url_template.format(
callbackurl=quote_plus(callback_url),
destination=quote_plus("https://console.aws.amazon.com/"),
signin_token=signin_token)
def get_yaml_from_repo(repo, full_name, commit_sha, cached=True):
# type: (Repo_ish, Text, bytes, bool) -> Any
"""Return decoded, struct-ified YAML data structure from
the given file in *repo* at *commit_sha*.
See :class:`relate.utils.Struct` for more on
struct-ification.
"""
if cached:
try:
import django.core.cache as cache
except ImproperlyConfigured:
cached = False
else:
from six.moves.urllib.parse import quote_plus
cache_key = "%%%2".join(
(CACHE_KEY_ROOT,
quote_plus(repo.controldir()), quote_plus(full_name),
commit_sha.decode()))
def_cache = cache.caches["default"]
result = None
# Memcache is apparently limited to 250 characters.
if len(cache_key) < 240:
result = def_cache.get(cache_key)
if result is not None:
return result
yaml_bytestream = get_repo_blob(
repo, full_name, commit_sha, allow_tree=False).data
yaml_text = yaml_bytestream.decode("utf-8")
if LINE_HAS_INDENTING_TABS_RE.search(yaml_text):
raise ValueError("File uses tabs in indentation. "
"This is not allowed.")
expanded = expand_yaml_macros(
repo, commit_sha, yaml_bytestream)
yaml_data = load_yaml(expanded) # type:ignore
result = dict_to_struct(yaml_data)
if cached:
def_cache.add(cache_key, result, None)
return result
def sn(self, query_str):
"""
计算 sn
"""
encoded_str = quote(query_str, safe=self.safe_chars)
raw_str = encoded_str + self.__sk
return hashlib.md5(quote_plus(raw_str).encode('utf-8')).hexdigest()
def get(self, request):
"""Render the certificates support view. """
context = {
"user_filter": unquote(quote_plus(request.GET.get("user", ""))),
"course_filter": request.GET.get("course_id", "")
}
return render_to_response("support/certificates.html", context)
def test_get_correct_authorization_url(redirect_url):
# pylint:disable=redefined-outer-name
fake_client_id = 'fake_client_id'
fake_client_secret = 'fake_client_secret'
oauth2 = OAuth2(
client_id=fake_client_id,
client_secret=fake_client_secret,
)
auth_url, csrf_token = oauth2.get_authorization_url(
redirect_url=redirect_url)
expected_auth_url_format = '{0}?state={1}&response_type=code&client_id={2}'
if redirect_url:
expected_auth_url_format += '&redirect_uri={3}'
assert auth_url == expected_auth_url_format.format(
API.OAUTH2_AUTHORIZE_URL,
csrf_token,
fake_client_id,
urlparse.quote_plus((redirect_url or '').encode('utf-8')),
)
assert re.match('^box_csrf_token_[A-Za-z0-9]{16}$', csrf_token)
def _create_dir_marker(self, env, account, container, obj):
"""
Create an empty object to mark a subdirectory. This is required to
quickly recurse on subdirectories, since with this middleware they
are stored on separate containers.
"""
path = quote_plus(
self.DELIMITER.join(('', 'v1', account, container, obj)))
req = make_subrequest(env,
method='PUT',
path=path,
body='',
swift_source=self.SWIFT_SOURCE)
req.headers['If-None-Match'] = '*'
req.headers['Content-Length'] = '0'
resp = req.get_response(self.app)
if not resp.is_success:
LOG.warn('%s: Failed to create directory placeholder in %s: %s',
self.SWIFT_SOURCE, container, resp.status)
close_if_possible(resp.app_iter)
def get_global_account_limit(self, account, rse_expression):
"""
List the account limit for the specific RSE expression.
:param account: The account name.
:param rse_expression: The rse expression.
"""
path = '/'.join([
self.ACCOUNTS_BASEURL, account, 'limits', 'global',
quote_plus(rse_expression)
])
url = build_url(choice(self.list_hosts), path=path)
res = self._send_request(url, type_='GET')
if res.status_code == codes.ok:
return next(self._load_json_data(res))
exc_cls, exc_msg = self._get_exception(headers=res.headers,
status_code=res.status_code,
data=res.content)
raise exc_cls(exc_msg)
def add_value(self, key, value):
"""
Sends the request to add a value to a key.
:param key: the name for key.
:param value: the value.
:return: True if value was created successfully.
:raises Duplicate: if valid already exists.
"""
path = '/'.join([self.META_BASEURL, quote_plus(key)]) + '/'
data = dumps({'value': value})
url = build_url(choice(self.list_hosts), path=path)
r = self._send_request(url, type='POST', data=data)
if r.status_code == codes.created:
return True
else:
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def expand(text, dictlist=[], valid=None, format=''):
result = StringIO()
textlist = re.split(var_pattern, text)
for x in textlist:
if x.startswith('%'):
x = x[1:].split('/')
name = x[0]
if valid:
if name not in valid:
result.write("(%s-NOT-VALID)" % name)
continue
else:
this_format = valid[name]
if len(x) > 1:
this_format = x[1]
else:
this_format = format
if name == '':
result.write('%')
else:
val = 'UNDEF'
for y in dictlist:
if name in y:
val = y[name]
break
if this_format == '' or this_format == 'text':
result.write(str(val))
elif this_format == 'cgi':
if isinstance(val, basestring):
val = quote_plus(val)
else:
val = urlencode(val)
result.write(val)
elif this_format == 'html':
val = cgi.escape(str(val), quote=True)
result.write(val)
else:
result.write(str(val))
else:
result.write(x)
return result.getvalue()
def _check_aliveness(self, base_url, vhosts, custom_tags):
"""
Check the aliveness API against all or a subset of vhosts. The API
will return {"status": "ok"} and a 200 response code in the case
that the check passes.
"""
for vhost in vhosts:
tags = ['vhost:{}'.format(vhost)] + custom_tags
# We need to urlencode the vhost because it can be '/'.
path = u'aliveness-test/{}'.format(quote_plus(vhost))
aliveness_url = urljoin(base_url, path)
aliveness_response = self._get_data(aliveness_url)
message = u"Response from aliveness API: {}".format(aliveness_response)
if aliveness_response.get('status') == 'ok':
status = AgentCheck.OK
else:
status = AgentCheck.CRITICAL
self.service_check('rabbitmq.aliveness', status, tags, message=message)
def delete_global_account_limit(self, account, rse_expression):
"""
Sends the request to remove a global account limit.
:param account: The name of the account.
:param rse_expression: The rse expression.
:return: True if quota was removed successfully. False otherwise.
:raises AccountNotFound: if account doesn't exist.
"""
path = '/'.join([self.ACCOUNTLIMIT_BASEURL, 'global', account, quote_plus(rse_expression)])
url = build_url(choice(self.list_hosts), path=path)
r = self._send_request(url, type='DEL')
if r.status_code == codes.ok:
return True
else:
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def set_global_account_limit(self, account, rse_expression, bytes):
"""
Sends the request to set a global account limit for an account.
:param account: The name of the account.
:param rse_expression: The rse expression.
:param bytes: An integer with the limit in bytes.
:return: True if quota was created successfully else False.
"""
data = dumps({'bytes': bytes})
path = '/'.join([self.ACCOUNTLIMIT_BASEURL, 'global', account, quote_plus(rse_expression)])
url = build_url(choice(self.list_hosts), path=path)
r = self._send_request(url, type='POST', data=data)
if r.status_code == codes.created:
return True
else:
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def calculate_new_path(dirname, base, ext, args):
stuff = [
base,
]
for key, val in args.items():
if key == "fm":
continue
if val is not None:
if isinstance(val, six.string_types):
# escape special characters in URLs for overlay / mask arguments
val = parse.quote_plus(val)
stuff.append("{}{}".format(key, val))
fmt = args.get('fm')
if fmt:
ext = FORMAT_MAP[fmt]['extension']
filename_with_args = "_".join(str(x) for x in stuff) + "." + ext
# if we enable compression we may want to modify the filename here to include *.gz
param_name = os.path.join(CACHE_DIR, dirname, filename_with_args)
return param_name
def unzip(path, dest, folder=None):
''' Unzip file. zipfile module seems to fail on android with badziperror.
'''
path = quote_plus(path)
root = "zip://" + path + '/'
if folder:
xbmcvfs.mkdir(os.path.join(dest, folder))
dest = os.path.join(dest, folder)
root = get_zip_directory(root, folder)
dirs, files = xbmcvfs.listdir(root)
if dirs:
unzip_recursive(root, dirs, dest)
for file in files:
unzip_file(os.path.join(root, file), os.path.join(dest, file))
LOG.info("Unzipped %s", path)
def set_peek(self, dataset, is_multi_byte=False):
if not dataset.dataset.purged:
if hasattr(dataset, 'history_id'):
params = {
"bundle": "display?id=%s&tofile=yes&toext=.zip" % dataset.id,
"buttonlabel": "Launch GMAJ",
"nobutton": "false",
"urlpause": "100",
"debug": "false",
"posturl": "history_add_to?%s" % "&".join("%s=%s" % (x[0], quote_plus(str(x[1]))) for x in [('copy_access_from', dataset.id), ('history_id', dataset.history_id), ('ext', 'maf'), ('name', 'GMAJ Output on data %s' % dataset.hid), ('info', 'Added by GMAJ'), ('dbkey', dataset.dbkey)])
}
class_name = "edu.psu.bx.gmaj.MajApplet.class"
archive = "/static/gmaj/gmaj.jar"
dataset.peek = create_applet_tag_peek(class_name, archive, params)
dataset.blurb = 'GMAJ Multiple Alignment Viewer'
else:
dataset.peek = "After you add this item to your history, you will be able to launch the GMAJ applet."
dataset.blurb = 'GMAJ Multiple Alignment Viewer'
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def list_dids_extended(self, scope, filters, did_type='collection', long=False, recursive=False):
"""
List all data identifiers in a scope which match a given pattern.
:param scope: The scope name.
:param filters: A nested dictionary of key/value pairs like [{'key1': 'value1', 'key2.lte': 'value2'}, {'key3.gte, 'value3'}].
Keypairs in the same dictionary are AND'ed together, dictionaries are OR'ed together. Keys should be suffixed
like <key>.<operation>, e.g. key1 >= value1 is equivalent to {'key1.gte': value}, where <operation> belongs to one
of the set {'lte', 'gte', 'gt', 'lt', 'ne' or ''}. Equivalence doesn't require an operator.
:param did_type: The type of the did: 'all'(container, dataset or file)|'collection'(dataset or container)|'dataset'|'container'|'file'
:param long: Long format option to display more information for each DID.
:param recursive: Recursively list DIDs content.
"""
path = '/'.join([self.DIDS_BASEURL, quote_plus(scope), 'dids', 'search_extended'])
# stringify dates.
if isinstance(filters, dict): # backwards compatability for filters as single {}
filters = [filters]
for or_group in filters:
for key, value in or_group.items():
if isinstance(value, datetime):
or_group[key] = date_to_str(value)
payload = {
'type': did_type,
'filters': filters,
'long': long,
'recursive': recursive
}
url = build_url(choice(self.list_hosts), path=path, params=payload)
r = self._send_request(url, type_='GET')
if r.status_code == codes.ok:
dids = self._load_json_data(r)
return dids
else:
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def _create_dir_marker(self, env, account, container, obj):
"""
Create an empty object to mark a subdirectory. This is required to
quickly recurse on subdirectories, since with this middleware they
are stored on separate containers.
"""
items = container.split(self.ENCODED_DELIMITER)
while items:
path = quote_plus(
self.DELIMITER.join(('', 'v1', account, container, obj)))
req = make_subrequest(env,
method='PUT',
path=path,
body='',
swift_source=self.SWIFT_SOURCE)
req.headers['If-None-Match'] = '*'
req.headers['Content-Length'] = '0'
LOG.debug("%s: Create placeholder %s in %s", self.SWIFT_SOURCE,
obj, container)
resp = req.get_response(self.app)
if resp.status_int == HTTP_PRECONDITION_FAILED:
LOG.debug('%s: directory placeholder already present '
'in %s', self.SWIFT_SOURCE, container)
close_if_possible(resp.app_iter)
break
if not resp.is_success:
LOG.warn(
'%s: Failed to create directory placeholder '
'in %s: %s', self.SWIFT_SOURCE, container, resp.status)
close_if_possible(resp.app_iter)
if not self.recursive_placeholders:
break
if items:
obj = items.pop() + self.DELIMITER
container = self.ENCODED_DELIMITER.join(items)
def _recursive_listing(self, env, account, ct_parts, header_cb):
"""
For each subdirectory marker encountered, make a listing subrequest,
and yield object list.
"""
sub_path = quote_plus(
self.DELIMITER.join(
('', 'v1', account, self.ENCODED_DELIMITER.join(ct_parts))))
LOG.debug("%s: Recursively listing '%s'", self.SWIFT_SOURCE, sub_path)
sub_req = make_subrequest(env.copy(),
method='GET',
path=sub_path,
body='',
swift_source=self.SWIFT_SOURCE)
params = sub_req.params
params['delimiter'] = self.DELIMITER
params['limit'] = '10000'
params['prefix'] = ''
sub_req.params = params
resp = sub_req.get_response(self.app)
obj_prefix = ''
if len(ct_parts) > 1:
obj_prefix = self.DELIMITER.join(ct_parts[1:] + ('', ))
if not resp.is_success or resp.content_length == 0:
LOG.warn("Failed to recursively list '%s': %s", obj_prefix,
resp.status)
return
with closing_if_possible(resp.app_iter):
items = json.loads(resp.body)
header_cb(resp.headers)
subdirs = [x['subdir'][:-1] for x in items if 'subdir' in x]
for obj in items:
if 'name' in obj:
obj['name'] = obj_prefix + obj['name']
yield obj
for subdir in subdirs:
for obj in self._recursive_listing(env, account,
ct_parts + (subdir, ),
header_cb):
yield obj
def make_franken_uri(path, qs):
"""Given two bytestrings, return a bytestring.
We want to pass ASCII to Request. However, our friendly neighborhood WSGI
servers do friendly neighborhood things with the Request-URI to compute
PATH_INFO and QUERY_STRING. In addition, our friendly neighborhood browser
sends "raw, unescaped UTF-8 bytes in the query during an HTTP request"
(http://web.lookout.net/2012/03/unicode-normalization-in-urls.html).
Our strategy is to try decoding to ASCII, and if that fails (we don't have
ASCII) then we'll quote the value before passing to Request. What encoding
are those bytes? Good question. The above blog post claims that experiment
reveals all browsers to send UTF-8, so let's go with that? BUT WHAT ABOUT
MAXTHON?!?!?!.
"""
if path:
try:
path.decode('ASCII') # NB: We throw away this unicode!
except UnicodeDecodeError:
# XXX How would we get non-ASCII here? The lookout.net post
# indicates that all browsers send ASCII for the path.
# Some servers (gevent) clobber %2F inside of paths, such
# that we see /foo%2Fbar/ as /foo/bar/. The %2F is lost to us.
parts = [urlparse.quote(x) for x in quoted_slash_re.split(path)]
path = b"%2F".join(parts)
if qs:
try:
qs.decode('ASCII') # NB: We throw away this unicode!
except UnicodeDecodeError:
# Cross our fingers and hope we have UTF-8 bytes from MSIE. Let's
# perform the percent-encoding that we would expect MSIE to have
# done for us.
qs = urlparse.quote_plus(qs)
qs = b'?' + qs
return path + qs
def scrape(self):
page = self.lxmlize(COUNCIL_PAGE)
members = page.xpath('//table[@id="MLAs"]//tr')[1:]
assert len(members), 'No members found'
for member in members:
if 'Vacant' not in member.xpath('./td')[0].text_content():
name = member.xpath('./td')[0].text_content().split('. ', 1)[1]
party = member.xpath('./td')[1].text
district = member.xpath('./td')[2].text_content()
url = member.xpath('./td[1]/a/@href')[0]
page = self.lxmlize(url)
p = Person(primary_org='legislature', name=name, district=district, role='MLA', party=party)
p.add_source(COUNCIL_PAGE)
p.add_source(url)
p.image = 'http://dbnwgw85c64xt.cloudfront.net/{}/185/259'.format(quote_plus(page.xpath('//div[contains(@class, "mla-image-cell")]/img/@src')[0]))
self.get(p.image) # trigger cache
contact = page.xpath('//div[@id="mla-contact"]/div[2]')[0]
website = contact.xpath('./div[3]/div[3]/div[2]/a')
if website:
p.add_link(website[0].text_content())
p.add_contact('address', ' '.join(contact.xpath('.//div[@class="col-md-4"][2]/div//text()')[1:9]), 'constituency')
phone_leg = contact.xpath('.//span[@id="MainContent_ContentBottom_Property6"]//text()')
if phone_leg:
p.add_contact('voice', phone_leg[0], 'legislature', area_code=306)
phone_const = contact.xpath('.//div[@class="col-md-4"]/div[4]/span/span/text()')
if phone_const:
p.add_contact('voice', phone_const[0], 'constituency', area_code=306)
email = self.get_email(contact, error=False)
if email:
p.add_contact('email', email)
yield p
def contains_content_items(self, request, pk, course_run_ids, program_uuids):
"""
Return whether or not the specified content is available to the EnterpriseCustomer.
Multiple course_run_ids and/or program_uuids query parameters can be sent to this view to check
for their existence in the EnterpriseCustomerCatalogs associated with this EnterpriseCustomer.
At least one course run key or program UUID value must be included in the request.
"""
enterprise_customer = self.get_object()
# Maintain plus characters in course key.
course_run_ids = [unquote(quote_plus(course_run_id)) for course_run_id in course_run_ids]
contains_content_items = False
for catalog in enterprise_customer.enterprise_customer_catalogs.all():
contains_course_runs = not course_run_ids or catalog.contains_courses(course_run_ids)
contains_program_uuids = not program_uuids or catalog.contains_programs(program_uuids)
if contains_course_runs and contains_program_uuids:
contains_content_items = True
break
return Response({'contains_content_items': contains_content_items})
def list_dids_extended(self,
scope,
filters,
did_type='collection',
long=False,
recursive=False):
"""
List all data identifiers in a scope which match a given pattern. Extended version that goes through plugin mechanism.
:param scope: The scope name.
:param filters: A dictionary of key/value pairs like {'type': 'dataset', 'scope': 'test'}.
:param did_type: The type of the did: 'all'(container, dataset or file)|'collection'(dataset or container)|'dataset'|'container'|'file'
:param long: Long format option to display more information for each DID.
:param recursive: Recursively list DIDs content.
"""
path = '/'.join(
[self.DIDS_BASEURL,
quote_plus(scope), 'dids', 'search_extended'])
payload = {}
for k, v in list(filters.items()):
if k in ('created_before', 'created_after'):
payload[k] = date_to_str(v)
else:
payload[k] = v
payload['long'] = long
payload['type'] = did_type
payload['recursive'] = recursive
url = build_url(choice(self.list_hosts), path=path, params=payload)
r = self._send_request(url, type_='GET')
if r.status_code == codes.ok:
dids = self._load_json_data(r)
return dids
else:
exc_cls, exc_msg = self._get_exception(headers=r.headers,
status_code=r.status_code,
data=r.content)
raise exc_cls(exc_msg)
def call_post_bootstrap(self, config):
"""
runs a script after initdb or custom bootstrap script is called and waits until completion.
"""
cmd = config.get('post_bootstrap') or config.get('post_init')
if cmd:
r = self._postgresql.config.local_connect_kwargs
if 'host' in r:
# '/tmp' => '%2Ftmp' for unix socket path
host = quote_plus(r['host']) if r['host'].startswith('/') else r['host']
else:
host = ''
# https://www.postgresql.org/docs/current/static/libpq-pgpass.html
# A host name of localhost matches both TCP (host name localhost) and Unix domain socket
# (pghost empty or the default socket directory) connections coming from the local machine.
r['host'] = 'localhost' # set it to localhost to write into pgpass
if 'user' in r:
user = r['user'] + '@'
else:
user = ''
if 'password' in r:
import getpass
r.setdefault('user', os.environ.get('PGUSER', getpass.getuser()))
connstring = 'postgres://{0}{1}:{2}/{3}'.format(user, host, r['port'], r['database'])
env = self._postgresql.write_pgpass(r) if 'password' in r else None
try:
ret = self._postgresql.cancellable.call(shlex.split(cmd) + [connstring], env=env)
except OSError:
logger.error('post_init script %s failed', cmd)
return False
if ret != 0:
logger.error('post_init script %s returned non-zero code %d', cmd, ret)
return False
return True
def __init__(self, args):
self.args = args
self.args.ssh_public_key = os.path.expanduser(
self.args.ssh_public_key
)
if not self.args.gitlab_repo:
self.args.gitlab_repo = self.args.github_repo
(self.args.gitlab_namespace,
self.args.gitlab_name) = self.args.gitlab_repo.split('/')
self.args.gitlab_repo = parse.quote_plus(self.args.gitlab_repo)
self.github = {
'url': "https://api.github.com",
'git': "https://github.com",
'repo': self.args.github_repo,
'token': self.args.github_token,
}
if self.args.branches:
self.github['branches'] = self.args.branches.split(',')
self.gitlab = {
'git': self.args.gitlab_url.replace('http://', 'git@'),
'host': self.args.gitlab_url,
'name': self.args.gitlab_name,
'namespace': self.args.gitlab_namespace,
'url': self.args.gitlab_url + "/api/v4",
'repo': self.args.gitlab_repo,
'token': self.args.gitlab_token,
}
if self.args.verbose:
level = logging.DEBUG
else:
level = logging.INFO
logging.getLogger('github2gitlab').setLevel(level)
self.tmpdir = "/tmp"
def test_setup_firewall_internal(self):
fake_rule = self._make_fake_fw_rule()
fake_router_info = self._make_fake_router_info()
fake_rule_cmd = 'fake-fw-rule0'
fake_zone_configure_rules = ['fake-config-rule0']
mock_api = mock.Mock()
mock_api_gen = mock.Mock(return_value=mock_api)
mock_get_firewall_rule = mock.Mock(return_value=[fake_rule_cmd])
mock_get_zone_cmds = mock.Mock(return_value=fake_zone_configure_rules)
with mock.patch.object(self.fwaas_driver, '_get_vyatta_client',
mock_api_gen), \
mock.patch.object(vyatta_fwaas.vyatta_utils, 'get_zone_cmds',
mock_get_zone_cmds), \
mock.patch.object(self.fwaas_driver, '_set_firewall_rule',
mock_get_firewall_rule):
self.fwaas_driver._setup_firewall(fake_router_info,
self.fake_firewall)
mock_api_gen.assert_called_once_with(fake_router_info.router)
mock_get_firewall_rule.assert_called_once_with(
self.fake_firewall_name, 1, fake_rule)
mock_get_zone_cmds.assert_called_once_with(mock_api,
fake_router_info,
self.fake_firewall_name)
cmds = [
vyatta_client.SetCmd(
vyatta_fwaas.FW_NAME.format(self.fake_firewall_name)),
vyatta_client.SetCmd(
vyatta_fwaas.FW_DESCRIPTION.format(
self.fake_firewall_name,
parse.quote_plus(self.fake_firewall['description']))),
vyatta_client.SetCmd(vyatta_fwaas.FW_ESTABLISHED_ACCEPT),
vyatta_client.SetCmd(vyatta_fwaas.FW_RELATED_ACCEPT),
fake_rule_cmd,
] + fake_zone_configure_rules
mock_api.exec_cmd_batch.assert_called_once_with(cmds)
def get_connections_stat(self, instance, base_url, object_type, vhosts, limit_vhosts, custom_tags):
"""
Collect metrics on currently open connection per vhost.
"""
grab_all_data = True
if self._limit_vhosts(instance):
grab_all_data = False
data = []
for vhost in vhosts:
url = "vhosts/{}/{}".format(quote_plus(vhost), object_type)
try:
data += self._get_data(urljoin(base_url, url))
except Exception as e:
# This will happen if there is no connection data to grab
self.log.debug("Couldn't grab connection data from vhost, %s: %s", vhost, e)
# sometimes it seems to need to fall back to this
if grab_all_data or not len(data):
data = self._get_data(urljoin(base_url, object_type))
stats = {vhost: 0 for vhost in vhosts}
connection_states = defaultdict(int)
for conn in data:
if conn['vhost'] in vhosts:
stats[conn['vhost']] += 1
# 'state' does not exist for direct type connections.
connection_states[conn.get('state', 'direct')] += 1
for vhost, nb_conn in iteritems(stats):
self.gauge('rabbitmq.connections', nb_conn, tags=['{}_vhost:{}'.format(TAG_PREFIX, vhost)] + custom_tags)
for conn_state, nb_conn in iteritems(connection_states):
self.gauge(
'rabbitmq.connections.state',
nb_conn,
tags=['{}_conn_state:{}'.format(TAG_PREFIX, conn_state)] + custom_tags,
)
def test_oauth2_start_flow_specified(self):
"""
Starts a GlobusNativeAppFlowManager with specified parameters,
Confirms flow is initialized as expected, and can be used.
"""
# starting with no flow
self.assertIsNone(self.nac.current_oauth2_flow_manager)
# confirms flow initialized with specified values
flow = self.nac.oauth2_start_flow(requested_scopes="scopes",
redirect_uri="uri",
state="state",
verifier=("v" * 43),
refresh_tokens=True)
self.assertIsInstance(flow, GlobusNativeAppFlowManager)
self.assertEqual(flow.redirect_uri, "uri")
self.assertEqual(flow.requested_scopes, "scopes")
self.assertEqual(flow.state, "state")
self.assertTrue(flow.refresh_tokens)
# confirm client can get url via flow
url_res = self.nac.oauth2_get_authorize_url()
verifier, remade_challenge = make_native_app_challenge("v" * 43)
expected_vals = [
self.nac.base_url + "v2/oauth2/authorize?",
"client_id=" + self.nac.client_id, "redirect_uri=" + "uri",
"scope=" + "scopes", "state=" + "state",
"code_challenge=" + quote_plus(remade_challenge),
"access_type=" + "offline"
]
for val in expected_vals:
self.assertIn(val, url_res)
# confirm client can try exchanging code for tokens via flow
with self.assertRaises(AuthAPIError) as apiErr:
self.nac.oauth2_exchange_code_for_tokens("invalid_code")
self.assertEqual(apiErr.exception.http_status, 401)
self.assertEqual(apiErr.exception.code, "Error")
def find(self, word):
response = get(URL_WORD.format(quote_plus(word)))
soup = BeautifulSoup(response.content)
# from ipdb import set_trace; set_trace()
resultados = soup.find('div', id='resultados')
#div = resultados.find().find_all('div')[5]
#varpts = div.find_all('span', class_='varpt')
#wordfrom = varpts[0].text
#part_of_speech = varpts[2].text
definitions = [p.text for p in resultados.find_all('p')]
part_of_speech = u', '.join(
[part.text for part in resultados.find_all('categoria_ext_aao')])
#part_of_speech = u'{0}'.format(part_of_speech)
script = resultados.find('script').text
wordId = re.search(r'verificaRelacionadasDef\((\d+)', script).group(1)
synonims = self._get_synonyms(word, wordId)
result = PriberamWord(word.decode('utf8'), part_of_speech, definitions,
synonims)
return result
def contains_content_items(self, request, pk, course_run_ids, program_uuids):
"""
Return whether or not the EnterpriseCustomerCatalog contains the specified content.
Multiple course_run_ids and/or program_uuids query parameters can be sent to this view to check
for their existence in the EnterpriseCustomerCatalog. At least one course run key
or program UUID value must be included in the request.
"""
enterprise_customer_catalog = self.get_object()
# Maintain plus characters in course key.
course_run_ids = [unquote(quote_plus(course_run_id)) for course_run_id in course_run_ids]
contains_content_items = True
if course_run_ids:
contains_content_items = enterprise_customer_catalog.contains_courses(course_run_ids)
if program_uuids:
contains_content_items = (
contains_content_items and
enterprise_customer_catalog.contains_programs(program_uuids)
)
return Response({'contains_content_items': contains_content_items})
def add_scope(self, account, scope):
"""
Sends the request to add a new scope.
:param account: the name of the account to add the scope to.
:param scope: the name of the new scope.
:return: True if scope was created successfully.
:raises Duplicate: if scope already exists.
:raises AccountNotFound: if account doesn't exist.
"""
path = '/'.join(
[self.SCOPE_BASEURL, account, 'scopes',
quote_plus(scope)])
url = build_url(choice(self.list_hosts), path=path)
r = self._send_request(url, type_='POST')
if r.status_code == codes.created:
return True
else:
exc_cls, exc_msg = self._get_exception(headers=r.headers,
status_code=r.status_code,
data=r.content)
raise exc_cls(exc_msg)
def dump_crypto_meta(crypto_meta):
"""
Serialize crypto meta to a form suitable for including in a header value.
The crypto-meta is serialized as a json object. The iv and key values are
random bytes and as a result need to be base64 encoded before sending over
the wire. Base64 encoding returns a bytes object in py3, to future proof
the code, decode this data to produce a string, which is what the
json.dumps function expects.
:param crypto_meta: a dict containing crypto meta items
:returns: a string serialization of a crypto meta dict
"""
def b64_encode_meta(crypto_meta):
return {
name: (base64.b64encode(value).decode() if name in ('iv', 'key')
else b64_encode_meta(value) if isinstance(value, dict)
else value)
for name, value in crypto_meta.items()}
# use sort_keys=True to make serialized form predictable for testing
return urlparse.quote_plus(
json.dumps(b64_encode_meta(crypto_meta), sort_keys=True))
def scope_list(self, scope, name=None, recursive=False):
"""
List data identifiers in a scope.
:param scope: The scope name.
:param name: The data identifier name.
:param recursive: boolean, True or False.
"""
payload = {}
path = '/'.join([self.DIDS_BASEURL, quote_plus(scope), ''])
if name:
payload['name'] = name
if recursive:
payload['recursive'] = True
url = build_url(choice(self.list_hosts), path=path, params=payload)
r = self._send_request(url, type_='GET')
if r.status_code == codes.ok:
return self._load_json_data(r)
else:
exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
raise exc_cls(exc_msg)
def build_candidates_list(election=conf['release']):
election_path = os.path.join(CANDIDATE_PATH, election)
if os.path.exists(election_path):
project_list = os.listdir(election_path)
else:
project_list = []
project_list.sort()
candidates_lists = {}
for project in project_list:
project_prefix = os.path.join(CANDIDATE_PATH, election, project)
file_list = filter(
lambda x: x.endswith(".txt"),
os.listdir(project_prefix),
)
candidates_list = []
for candidate_file in file_list:
filepath = os.path.join(project_prefix, candidate_file)
candidates_list.append({
'url':
('%s/%s/plain/%s' %
(CGIT_URL, ELECTION_REPO, quote_plus(filepath, safe='/'))),
'ircname':
candidate_file[:-4].replace('`', r'\`'),
'email':
get_email(filepath),
'fullname':
get_fullname(filepath)
})
candidates_list.sort(key=lambda x: x['fullname'])
candidates_lists[project] = candidates_list
return {
'election': election,
'projects': project_list,
'candidates': candidates_lists
}
def test_mdx_metadata_freshness_period_expired():
"""Ensure that metadata is not refreshed if not expired."""
entity_id = "http://xenosmilus.umdc.umu.se/simplesaml/saml2/idp/metadata.php"
url = "http://mdx.example.com/entities/{}".format(
parse.quote_plus(MetaDataMDX.sha1_entity_transform(entity_id)))
responses.add(
responses.GET,
url,
body=TEST_METADATA_STRING,
status=200,
content_type=SAML_METADATA_CONTENT_TYPE,
)
mdx = MetaDataMDX("http://mdx.example.com",
freshness_period="P0Y0M0DT0H2M0S")
mdx._is_metadata_fresh = Mock(return_value=False)
mdx.single_sign_on_service(entity_id, BINDING_HTTP_REDIRECT)
assert entity_id in mdx.entity
mdx.single_sign_on_service(entity_id, BINDING_HTTP_REDIRECT)
assert len(responses.calls) == 2
