def _append_defaults(self, service_json, operation='create'):
# default origin rule
for origin in service_json.get('origins', []):
if origin.get('rules') is None:
# add a rules section
origin['rules'] = []
if origin.get('rules') == []:
# add the /* default request_url rule
default_rule = rule.Rule(name="default", request_url='/*')
origin['rules'].append(default_rule.to_dict())
if operation == 'create':
# default caching rule
if not service_json.get('caching'):
# add the /* default request_url rule
default_rule = rule.Rule(name="default", request_url='/*')
default_ttl = self.provider_conf.default_cache_ttl
default_cache = cachingrule.CachingRule(name='default',
ttl=default_ttl,
rules=[default_rule])
service_json['caching'] = [default_cache.to_dict()]
for caching_entry in service_json.get('caching', []):
if caching_entry.get('rules') is None:
# add a rules section
caching_entry['rules'] = []
if caching_entry.get('rules') == []:
# add the /* default request_url rule
default_rule = rule.Rule(name="default", request_url='/*')
caching_entry['rules'].append(default_rule.to_dict())
def test_rule(self):
name = 'name'
http_host = 'www.mywebsite.com'
client_ip = '192.168.1.1'
http_method = 'POST'
request_url = '/index.html'
myrule = rule.Rule(name)
# test all properties
# name
self.assertEqual(myrule.name, name)
self.assertRaises(AttributeError, setattr, myrule, 'name', name)
# http_host
self.assertEqual(myrule.http_host, None)
myrule.http_host = http_host
self.assertEqual(myrule.http_host, http_host)
# client_ip
self.assertEqual(myrule.client_ip, None)
myrule.client_ip = client_ip
self.assertEqual(myrule.client_ip, client_ip)
# http_method
self.assertEqual(myrule.http_method, None)
myrule.http_method = http_method
self.assertEqual(myrule.http_method, http_method)
# request_url
self.assertEqual(myrule.request_url, None)
myrule.request_url = request_url
self.assertEqual(myrule.request_url, request_url)
def test_process_caching_rules(self):
controller = services.ServiceController(self.driver)
caching_rule_entry = rule.Rule('index', request_url='*.jpg')
caching_rule = cachingrule.CachingRule('home',
600,
rules=[caching_rule_entry])
caching_rules = [caching_rule]
rules_list = [{
'matches': [{
'name': 'url-wildcard',
'value': u'/*'
}],
'behaviors': [{
'params': {
'hostHeaderValue': '-',
'cacheKeyType': 'digital_property',
'cacheKeyValue': '-',
'originDomain': 'www.mydomain.com',
'hostHeaderType': 'digital_property'
},
'name': 'origin',
'value': '-'
}]
}]
controller._process_caching_rules(caching_rules, rules_list)
caching_rule_valid = False
for caching_rule in rules_list:
matches = caching_rule['matches']
for match in matches:
if match['value'] == u'/*.jpg':
caching_rule_valid = True
break
self.assertTrue(caching_rule_valid)
def init_from_dict(cls, dict_obj):
"""Construct a model instance from a dictionary.
This serves as a 2nd constructor
:param dict_obj: dictionary object
:returns o
"""
o = cls("unnamed")
o.origin = dict_obj.get("origin", "unnamed")
o.port = dict_obj.get("port", 80)
o.ssl = dict_obj.get("ssl", False)
o.hostheadertype = dict_obj.get("hostheadertype", "domain")
o.hostheadervalue = dict_obj.get("hostheadervalue", None)
if o.hostheadertype == 'origin':
o.hostheadervalue = o.origin
rules_dict_list = dict_obj.get("rules", [])
o.rules = []
for rule_dict in rules_dict_list:
new_rule = rule.Rule(rule_dict['name'])
del rule_dict['name']
new_rule.from_dict(rule_dict)
o.rules.append(new_rule)
return o
def test_process_origin_rule(self):
controller = services.ServiceController(self.driver)
rule_entry = rule.Rule('index', request_url='*.jpg')
origin_rule = origin.Origin(origin='poppy.com', rules=[rule_entry])
rules_list = [{
'matches': [{
'name': 'url-wildcard',
'value': u'/*'
}],
'behaviors': [{
'params': {
'hostHeaderValue': '-',
'cacheKeyType': 'digital_property',
'cacheKeyValue': '-',
'originDomain': 'www.mydomain.com',
'hostHeaderType': 'digital_property'
},
'name': 'origin',
'value': '-'
}]
}]
controller._process_new_origin(origin_rule, rules_list)
origin_rule_valid = False
for origin_rule in rules_list:
matches = origin_rule['matches']
for match in matches:
if match['value'] == u'/*.jpg':
origin_rule_valid = True
break
self.assertTrue(origin_rule_valid)
def init_from_dict(cls, dict_obj):
"""Construct a model instance from a dictionary.
This serves as a 2nd constructor
:param dict_obj: dictionary object
:returns o
"""
access = dict_obj.get("access", 'whitelist')
o = cls("unnamed", access)
o.name = dict_obj.get("name", "unnamed").strip()
rules_dict_list = dict_obj.get("rules", [])
for val in rules_dict_list:
val['name'] = val['name'].strip()
if 'referrer' in val:
val['referrer'] = val['referrer'].strip()
elif 'geography' in val:
val['geography'] = val['geography'].strip()
o.rules = []
for rule_dict in rules_dict_list:
new_rule = rule.Rule(rule_dict['name'])
del rule_dict['name']
new_rule.from_dict(rule_dict)
o.rules.append(new_rule)
return o
def setUp(self):
super(TestServiceModel, self).setUp()
self.project_id = str(uuid.uuid4())
self.service_id = str(uuid.uuid4())
self.service_name = uuid.uuid1()
self.flavor_id = "strawberry"
self.myorigins = []
self.mydomains = []
self.myrestrictions = []
self.mycaching = []
self.log_delivery = {"enabled": False}
self.myorigins.append(origin.Origin('mysite.com'))
self.myorigins.append(origin.Origin('yoursite.io', port=80, ssl=True))
self.mydomains.append(domain.Domain('oursite.org'))
self.mydomains.append(domain.Domain('wiki.cc', 'https', 'shared'))
# test a rule with referrer restriction
r1 = restriction.Restriction('referrer_site', 'whitelist')
self.r1_rules = [rule.Rule('referrer_restriction_rule_1')]
self.r1_rules[0].http_host = 'www.some_bad_site.com'
r1.rules = self.r1_rules
self.myrestrictions.append(r1)
self.myrestrictions.append(
restriction.Restriction('client_ip', 'whitelist'))
self.mycaching.append(cachingrule.CachingRule('images', 3600))
self.mycaching.append(cachingrule.CachingRule('js', 7200))
def load_from_json(json_data):
name = json_data.get('name', None)
res = rule.Rule(name)
res.referrer = json_data.get('referrer', None)
res.http_host = json_data.get('http_host', None)
res.http_method = json_data.get('http_method', None)
res.client_ip = json_data.get('client_ip', None)
res.request_url = json_data.get('request_url', None)
res.geography = json_data.get('geography', None)
return res
def _append_defaults(self, service_json, operation='create'):
"""Add defaults to the service.
If the service rules are None or Empty, add default rule.
If the operation is 'create', add default ttl and cache.
:param dict service_json: Service object represented as a dict
:param str operation: (Default 'create') Name of operation
"""
# default origin rule
for origin in service_json.get('origins', []):
if origin.get('rules') is None:
# add a rules section
origin['rules'] = []
if origin.get('rules') == []:
# add the /* default request_url rule
default_rule = rule.Rule(name="default", request_url='/*')
origin['rules'].append(default_rule.to_dict())
if operation == 'create':
# default caching rule
if not service_json.get('caching'):
# add the /* default request_url rule
default_rule = rule.Rule(name="default", request_url='/*')
default_ttl = self.provider_conf.default_cache_ttl
default_cache = cachingrule.CachingRule(name='default',
ttl=default_ttl,
rules=[default_rule])
service_json['caching'] = [default_cache.to_dict()]
for caching_entry in service_json.get('caching', []):
if caching_entry.get('rules') is None:
# add a rules section
caching_entry['rules'] = []
if caching_entry.get('rules') == []:
# add the /* default request_url rule
default_rule = rule.Rule(name="default", request_url='/*')
caching_entry['rules'].append(default_rule.to_dict())
def format_result(result):
service_id = result.get('service_id')
name = str(result.get('service_name'))
origins = [o for o in result.get('origins', [])]
domains = [d for d in result.get('domains', [])]
origins = [
origin.Origin(o['origin'],
hostheadertype='domain',
hostheadervalue='blog.mywebsite.com',
port=o.get('port', 80),
ssl=o.get('ssl', False)) for o in origins
]
domains = [
domain.Domain(d['domain'], d['protocol'], d['certificate'])
for d in domains
]
restrictions = [
restriction.Restriction(r.get('name'), r.get(
'access', 'whitelist'), [
rule.Rule(r_rule.get('name'),
referrer=r_rule.get('referrer'),
client_ip=r_rule.get('client_ip'),
geography=r_rule.get('geography'),
request_url=r_rule.get('request_url', "/*")
or "/*") for r_rule in r['rules']
]) for r in result.get('restrictions', [])
]
flavor_id = result.get('flavor_id')
s = service.Service(service_id,
name,
domains,
origins,
flavor_id,
restrictions=restrictions)
provider_detail_results = result.get('provider_details') or {}
provider_details_dict = {}
for provider_name in provider_detail_results:
provider_detail_dict = json.loads(
provider_detail_results[provider_name])
provider_service_id = provider_detail_dict.get('id', None)
access_urls = provider_detail_dict.get('access_urls', [])
status = provider_detail_dict.get('status', u'unknown')
provider_detail_obj = provider_details.ProviderDetail(
provider_service_id=provider_service_id,
access_urls=access_urls,
status=status)
provider_details_dict[provider_name] = provider_detail_obj
s.provider_details = provider_details_dict
return s
def init_from_dict(cls, dict_obj):
"""Construct a model instance from a dictionary.
This serves as a 2nd constructor
:param dict_obj: dictionary object
:returns o
"""
o = cls("unnamed", 3600)
o.caching = dict_obj.get("caching", "unnamed")
o.name = dict_obj.get("name", "unnamed")
o.ttl = dict_obj.get("ttl", 3600)
rules_dict_list = dict_obj.get("rules", [])
o.rules = []
for rule_dict in rules_dict_list:
new_rule = rule.Rule(rule_dict['name'])
del rule_dict['name']
new_rule.from_dict(rule_dict)
o.rules.append(new_rule)
return o
def test_process_restriction_rules(self):
controller = services.ServiceController(self.driver)
rule_entry = rule.Rule('index',
request_url='*.jpg',
referrer='www.poppy.com')
restriction_rule = restriction.Restriction(name='restriction',
rules=[rule_entry])
restriction_rules = [restriction_rule]
rules_list = [{
'matches': [{
'name': 'url-wildcard',
'value': u'/*'
}],
'behaviors': [{
'params': {
'hostHeaderValue': '-',
'cacheKeyType': 'digital_property',
'cacheKeyValue': '-',
'originDomain': 'www.mydomain.com',
'hostHeaderType': 'digital_property'
},
'name': 'origin',
'value': '-'
}]
}]
controller._process_restriction_rules(restriction_rules, rules_list)
restriction_rule_valid = False
for restriction_rule in rules_list:
matches = restriction_rule['matches']
for match in matches:
if match['value'] == u'/*.jpg':
restriction_rule_valid = True
break
self.assertTrue(restriction_rule_valid)
def format_result(result):
"""format_result.
:param result
:returns formatted result
"""
service_id = result.get('service_id')
project_id = result.get('project_id')
name = result.get('service_name')
flavor_id = result.get('flavor_id')
origins = [json.loads(o) for o in result.get('origins', []) or []]
domains = [json.loads(d) for d in result.get('domains', []) or []]
restrictions = [
json.loads(r) for r in result.get('restrictions', []) or []
]
caching_rules = [
json.loads(c) for c in result.get('caching_rules', []) or []
]
log_delivery = json.loads(result.get('log_delivery', '{}') or '{}')
operator_status = result.get('operator_status', 'enabled')
# create models for each item
origins = [
origin.Origin(o['origin'], o.get('hostheadertype', 'domain'),
o.get('hostheadervalue', None), o.get('port', 80),
o.get('ssl', False), [
rule.Rule(rule_i.get('name'),
request_url=rule_i.get('request_url'))
for rule_i in o.get('rules', [])
]) for o in origins
]
domains = [
domain.Domain(d['domain'], d.get('protocol', 'http'),
d.get('certificate', None)) for d in domains
]
restrictions = [
restriction.Restriction(r.get('name'), r.get(
'access', 'whitelist'), [
rule.Rule(r_rule.get('name'),
referrer=r_rule.get('referrer'),
client_ip=r_rule.get('client_ip'),
geography=r_rule.get('geography'),
request_url=r_rule.get('request_url', "/*")
or "/*") for r_rule in r['rules']
]) for r in restrictions
]
caching_rules = [
cachingrule.CachingRule(
caching_rule.get('name'), caching_rule.get('ttl'), [
rule.Rule(rule_i.get('name'),
request_url=rule_i.get('request_url', '/*')
or '/*') for rule_i in caching_rule['rules']
]) for caching_rule in caching_rules
]
log_delivery = ld.LogDelivery(log_delivery.get('enabled', False))
# create the service object
s = service.Service(service_id=service_id,
name=name,
domains=domains,
origins=origins,
flavor_id=flavor_id,
caching=caching_rules,
restrictions=restrictions,
log_delivery=log_delivery,
operator_status=operator_status,
project_id=project_id)
# format the provider details
provider_detail_results = result.get('provider_details') or {}
provider_details_dict = {}
for provider_name in provider_detail_results:
provider_detail_dict = json.loads(
provider_detail_results[provider_name])
provider_service_id = provider_detail_dict.get('id', None)
access_urls = provider_detail_dict.get('access_urls', [])
status = provider_detail_dict.get('status', u'unknown')
domains_certificate_status = (provider_detail_dict.get(
'domains_certificate_status', {}))
error_message = provider_detail_dict.get('error_message', None)
provider_detail_obj = provider_details.ProviderDetail(
provider_service_id=provider_service_id,
access_urls=access_urls,
domains_certificate_status=domains_certificate_status,
status=status,
error_message=error_message)
provider_details_dict[provider_name] = provider_detail_obj
s.provider_details = provider_details_dict
# return the service
return s
