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