def resolve(self, import_url):
failed_urls = {}
# trying to find a matching rule that can resolve this url
matched_any_rule = False
for rule in self.rules:
# the validate method checks that the dict has exactly 1 element
prefix, value = list(rule.items())[0]
prefix_len = len(prefix)
if prefix == import_url[:prefix_len]:
matched_any_rule = True
# found a matching rule
url_to_resolve = value + import_url[prefix_len:]
# trying to resolve the resolved_url
if url_to_resolve not in failed_urls:
# there is no point to try to resolve the same url twice
try:
return read_import(url_to_resolve)
except DSLParsingLogicException as ex:
# failed to resolve current rule,
# continue to the next one
failed_urls[url_to_resolve] = str(ex)
if matched_any_rule and not self._fallback:
msg = 'Failed to resolve the following urls: {0}'.format(
failed_urls)
ex = DSLParsingLogicException(13, msg)
ex.failed_import = import_url
raise ex
# failed to resolve the url using the rules
# trying to open the original url
try:
return read_import(import_url)
except DSLParsingLogicException as ex:
if not self.rules:
raise
if not failed_urls:
# no matching rules
msg = 'None of the resolver rules {0} was applicable, ' \
'failed to resolve the original import url: {1} '\
.format(self.rules, ex)
else:
# all urls failed to be resolved
msg = 'Failed to resolve the following urls: {0}. ' \
'In addition, failed to resolve the original ' \
'import url - {1}'.format(failed_urls, ex)
ex = DSLParsingLogicException(13, msg)
ex.failed_import = import_url
raise ex
def resolve(self, import_url):
failed_urls = {}
# trying to find a matching rule that can resolve this url
for rule in self.rules:
key = list(rule.keys())[0]
value = list(rule.values())[0]
prefix = key
prefix_len = len(key)
if prefix == import_url[:prefix_len]:
# found a matching rule
url_to_resolve = value + import_url[prefix_len:]
# trying to resolve the resolved_url
if url_to_resolve not in failed_urls.keys():
# there is no point to try to resolve the same url twice
try:
return read_import(url_to_resolve)
except DSLParsingLogicException as ex:
# failed to resolve current rule,
# continue to the next one
failed_urls[url_to_resolve] = str(ex)
# failed to resolve the url using the rules
# trying to open the original url
try:
return read_import(import_url)
except DSLParsingLogicException as ex:
if not self.rules:
raise
if not failed_urls:
# no matching rules
msg = 'None of the resolver rules {0} was applicable, ' \
'failed to resolve the original import url: {1} '\
.format(self.rules, ex)
else:
# all urls failed to be resolved
msg = 'Failed to resolve the following urls: {0}. ' \
'In addition, failed to resolve the original ' \
'import url - {1}'.format(failed_urls, ex)
ex = DSLParsingLogicException(13, msg)
ex.failed_import = import_url
raise ex
def resolve(self, import_url):
failed_urls = {}
# trying to find a matching rule that can resolve this url
for rule in self.rules:
key = rule.keys()[0]
value = rule.values()[0]
prefix = key
prefix_len = len(key)
if prefix == import_url[:prefix_len]:
# found a matching rule
url_to_resolve = value + import_url[prefix_len:]
# trying to resolve the resolved_url
if url_to_resolve not in failed_urls.keys():
# there is no point to try to resolve the same url twice
try:
return read_import(url_to_resolve)
except DSLParsingLogicException, ex:
# failed to resolve current rule,
# continue to the next one
failed_urls[url_to_resolve] = str(ex)
def resolve(self, import_url):
failed_urls = {}
# trying to find a matching rule that can resolve this url
for rule in self.rules:
key = rule.keys()[0]
value = rule.values()[0]
prefix = key
prefix_len = len(key)
if prefix == import_url[:prefix_len]:
# found a matching rule
url_to_resolve = value + import_url[prefix_len:]
# trying to resolve the resolved_url
if url_to_resolve not in failed_urls.keys():
# there is no point to try to resolve the same url twice
try:
return read_import(url_to_resolve)
except DSLParsingLogicException, ex:
# failed to resolve current rule,
# continue to the next one
failed_urls[url_to_resolve] = str(ex)
class DefaultImportResolver(AbstractImportResolver):
"""
This class is a default implementation of an import resolver.
This resolver uses the rules to replace URL's prefix with another prefix
and tries to resolve the new URL (after the prefix has been replaced).
If there aren't any rules, none of the rules matches or
none of the prefix replacements works,
the resolver will try to use the original URL.
Each rule in the ``rules`` list is expected to be
a dictionary with one (key, value) pair which represents
a prefix and its replacement which can be used to resolve the import url.
The resolver will go over the rules and for each matching rule
(its key is a prefix of the url) it will replace the prefix
with the value and will try to resolve the new url.
For example:
The rules list: [
{'http://prefix1': 'http://prefix1_replacement'},
{'http://prefix2': 'http://prefix2_replacement1'},
{'http://prefix2': 'http://prefix2_replacement2'}
]
contains three rules that can be used for resolve URLs that
starts with 'http://prefix1' and 'http://prefix2'.
If the url is 'http://prefix2.suffix2.org' than the resolve method
will find a match in both the second and the third rules.
It will first try to apply the second rule by replacing the url's
prefix with the second rule value ('http://prefix2_replacement1')
and will try to resolve the new url:
'http://prefix2_replacement1.suffix2.org'.
In case this url cannot be resolved, it will try to apply
the third rule by replacing the url's prefix with
the third rule value ('http://prefix2_replacement2')
and will try to resolve the url:
'http://prefix2_replacement2.suffix2.org'.
If this url, also, cannot be resolved,
it will try to resolve the original url,
i.e. http://prefix2.suffix2.org'
In case that all the resolve attempts will fail,
a DSLParsingLogicException will be raise.
"""
def __init__(self, rules=None):
# set the rules
self.rules = rules
if self.rules is None:
self.rules = DEFAULT_RULES
self._validate_rules()
def resolve(self, import_url):
failed_urls = {}
# trying to find a matching rule that can resolve this url
for rule in self.rules:
key = rule.keys()[0]
value = rule.values()[0]
prefix = key
prefix_len = len(key)
if prefix == import_url[:prefix_len]:
# found a matching rule
url_to_resolve = value + import_url[prefix_len:]
# trying to resolve the resolved_url
if url_to_resolve not in failed_urls.keys():
# there is no point to try to resolve the same url twice
try:
return read_import(url_to_resolve)
except DSLParsingLogicException, ex:
# failed to resolve current rule,
# continue to the next one
failed_urls[url_to_resolve] = str(ex)
# failed to resolve the url using the rules
# trying to open the original url
try:
return read_import(import_url)
except DSLParsingLogicException, ex:
if not self.rules:
raise
if not failed_urls:
# no matching rules
msg = 'None of the resolver rules {0} was applicable, ' \
'failed to resolve the original import url: {1} '\
.format(self.rules, ex)
else:
# all urls failed to be resolved
msg = 'Failed to resolve the following urls: {0}. ' \
'In addition, failed to resolve the original ' \
'import url - {1}'.format(failed_urls, ex)
ex = DSLParsingLogicException(13, msg)
ex.failed_import = import_url
raise ex
