def delete(self, request, obj_id):
try:
cache = CacheRule.objects.get(pk=obj_id)
domain = Domain.objects.get(pk=cache.domain_id)
domain_manager = middware.DomainManage()
ret = domain_manager.find(domain.domain_id)
domain_class = ret.getDomain()
cacheBehaviors = domain_class.cacheBehaviors
if cacheBehaviors is not None:
for i in cacheBehaviors:
if cache.pathPattern == i.pathPattern:
cacheBehaviors.remove(i)
domain_class = middware.domainApi.Domain(
domainId=domain.domain_id, cacheBehaviors=cacheBehaviors)
domain_manager.modify(domain_class)
cache.delete()
except Exception:
obj = self.table.get_object_by_id(obj_id)
name = self.table.get_object_display(obj)
msg = _('Unable to delete domain %s') % name
LOG.info(msg)
messages.error(request, msg)
exceptions.handle(request, msg)
redirect = reverse(self.redirect_url)
raise exceptions.Http302(redirect, message=msg)
def get_context_data(self, **kwargs):
context = super(VerifyView, self).get_context_data(**kwargs)
domain_id = self.kwargs['domain_id']
domain = Domain.objects.get(pk=domain_id)
domain_name = domain.domain_name
check_method = middware.DomainManage()
check_info = check_method.verify_file_check(str(domain_name))
memcached_servers = settings.CACHES.get("default").get("LOCATION")
mc = memcache.Client(memcached_servers)
domain_uuid = mc.get(str(domain_name))
if domain.status == 'unverified' or domain.status == 'failed':
if domain_uuid is not None:
if not check_info:
context["message"] = _(
"Please create name which name is on below into your web server(%s),"
"and write: ") % domain_name
context["uuid"] = domain_uuid
context["file"] = domain_uuid + '.txt'
msg = _("Not detected verification file")
messages.warning(self.request, msg)
else:
context["message"] = _(
"Verification file has been detected, please verify")
else:
domain.status = 'failed'
domain.save()
else:
context["disable"] = 'disabled="disable"'
context["message"] = _("The %s status is %s") % (
domain.domain_name, _(domain.status))
args = (self.kwargs['domain_id'], )
context['submit_url'] = reverse(self.submit_url, args=args)
return context
def delete(self, request, obj_id):
try:
access = AccessControl.objects.get(pk=obj_id)
domain = Domain.objects.get(pk=access.domain_id)
domain_manager = middware.DomainManage()
ret = domain_manager.find(domain.domain_id)
domain_class = ret.getDomain()
visitControlRules = domain_class.visitControlRules
if visitControlRules is not None:
for i in domain_class.visitControlRules:
if access.pathPattern == i.pathPattern:
visitControlRules.remove(i)
domain_class = middware.domainApi.Domain(
domainId=domain.domain_id,
visitControlRules=domain_class.visitControlRules)
domain_manager.modify(domain_class)
access.delete()
except Exception:
obj = self.table.get_object_by_id(obj_id)
name = self.table.get_object_display(obj)
msg = _('Unable to delete domain %s') % name
LOG.info(msg)
messages.error(request, msg)
exceptions.handle(request, msg)
redirect = reverse(self.redirect_url)
raise exceptions.Http302(redirect, message=msg)
def delete(self, request, obj_id):
try:
# 执行删除前状态检查，当状态为"unverified"或"failed"时直接删除数据库记录
# 否则更新状态为"deleted",保证数据统计时有记录，然后调用网宿api，删除加速记录
domain = Domain.objects.get(pk=obj_id)
cdn = middware.DomainManage()
if domain.status == "unverified" or domain.status == "failed" or domain.status == "addfailed" \
or domain.status == 'verified':
domain.delete()
elif domain.status == 'inProgress':
msg = _("%s status is %s, can not do this action") % (
domain.domain_name, _(domain.status))
messages.warning(request, msg)
else:
domain.status = 'deleted'
domain.deleted_at = datetime.now()
domain.save()
cdn.delete(domainId=domain.domain_id)
except Exception:
name = self.table.get_object_display(obj_id)
msg = _('Unable to delete domain %s') % name
LOG.info(msg)
messages.error(request, msg)
exceptions.handle(request, msg)
redirect = reverse(self.redirect_url)
raise exceptions.Http302(redirect, message=msg)
def verify_view(request, domain_id):
redirect_url = reverse_lazy('horizon:cdn:cdn.cdn_domain_manager:index')
try:
domain_id = domain_id
domain_list = Domain.objects.get(pk=domain_id)
domain_name = domain_list.domain_name
origin_type = domain_list.source_type
origin_address = domain_list.sourceaddress_set.filter(
domain_id=domain_id)
if origin_type == 'url':
origin_config = middware.domainApi.OriginConfig(
originDomainName=origin_address[0].source_address)
else:
originips = [i.source_address for i in origin_address]
origin_config = middware.domainApi.OriginConfig(
originIps=originips)
domain_class = middware.domainApi.Domain(domainName=domain_name,
comment='syscloud',
originConfig=origin_config,
serviceType='web')
domain = middware.DomainManage()
if domain_list.status == 'unverified' or domain_list.status == 'failed':
if domain.verify_file_check(str(domain_name)):
ret = domain.add(domain_class)
msg = ret.getMsg()
status = ret.getRet()
if status == 202:
domain_list.status = 'inProgress'
domain_list.save()
messages.success(request, msg)
else:
messages.error(request, msg)
logging.warning('CDN:' + domain_name + ':' + msg)
domain_list.error_log = msg
domain_list.status = 'addfailed'
domain_list.save()
else:
domain_list.status = 'failed'
domain_list.save()
elif domain_list.status == 'addfailed':
msg = _("Please check the domain config")
messages.warning(request, msg)
else:
msg = _("the %s status is %s") % (domain_list.domain_name,
_(domain_list.status))
messages.warning(request, msg)
return HttpResponseRedirect(redirect_url)
except Exception:
msg = _('Failed')
redirect = redirect_url
exceptions.handle(request, msg, redirect=redirect)
return False
def form_valid(self, form):
try:
handled = form.handle(self.request, form.cleaned_data)
except Exception:
handled = None
exceptions.handle(self.request)
if handled:
domain_id = self.kwargs["domain_id"]
source_type = form.cleaned_data["source_type"]
domain = Domain.objects.get(pk=domain_id)
domain.source_type = source_type
origin_address = SourceAddress.objects.filter(domain_id=domain_id)
if source_type == 'ip':
source_address = form.cleaned_data["origin_config_a"]
origin_address.delete()
clear_list = source_address.strip('\r\n').split('\r\n')
for i in clear_list:
origin_address.create(domain_id=domain_id,
source_address=i)
origin_config = middware.domainApi.OriginConfig(
originIps=source_address.split('\r\n'))
else:
source_address = form.cleaned_data["origin_config_b"]
origin_address.delete()
origin_address.create(domain_id=domain_id,
source_address=source_address)
origin_config = middware.domainApi.OriginConfig(
originDomainName=source_address)
domain.save()
if domain.domain_id is not None:
domain_class = middware.domainApi.Domain(
domainId=domain.domain_id, originConfig=origin_config)
modify = middware.DomainManage()
ret = modify.modify(domain_class)
if ret.getMsg() == 'success':
msg = _("modify successfully")
messages.success(self.request, msg)
else:
msg = _("modify failed")
messages.error(self.request, msg)
redirect_url = self.get_success_url()
return HttpResponseRedirect(redirect_url)
else:
msg = _("modify successfully")
redirect_url = self.get_success_url()
messages.success(self.request, msg)
return HttpResponseRedirect(redirect_url)
else:
return self.form_invalid(form)
def form_valid(self, form):
try:
handled = form.handle(self.request, form.cleaned_data)
except Exception:
handled = None
exceptions.handle(self.request)
if handled:
domain_id = self.kwargs['domain_id']
cache_type = form.cleaned_data['type']
ignore = form.cleaned_data["ignore"]
time = form.cleaned_data["time"]
domain = Domain.objects.get(pk=domain_id)
if domain.status == 'Deployed':
modify = middware.DomainManage()
ret = modify.find(domain.domain_id)
domain_result = ret.getDomain()
cacheBehavior = middware.domainApi.CacheBehavior(
pathPattern=cache_type,
ignoreCacheControl=ignore,
cacheTtl=time)
if domain_result.cacheBehaviors is not None:
domain_class = middware.domainApi.Domain(
domainId=domain.domain_id,
cacheBehaviors=domain_result.cacheBehaviors +
[cacheBehavior])
else:
domain_class = middware.domainApi.Domain(
domainId=domain.domain_id,
cacheBehaviors=[cacheBehavior])
ret = modify.modify(domain_class)
if ret.getMsg() == 'success':
msg = _("modify successfully")
messages.success(self.request, msg)
cache_id = self.kwargs["cache_id"]
cache = CacheRule.objects.get(pk=cache_id)
cache.pathPattern = cache_type
cache.ignoreCacheControl = ignore
cache.cacheTtl = time
cache.save()
else:
messages.error(self.request, ret.getMsg())
redirect_url = self.get_success_url()
return HttpResponseRedirect(redirect_url)
else:
msg = _("%s status is %s, can not do this action") % (
domain.domain_name, _(domain.status))
messages.warning(self.request, msg)
redirect_url = self.get_success_url()
return HttpResponseRedirect(redirect_url)
def enable(self, request, obj_id):
try:
domain = Domain.objects.get(pk=obj_id)
if domain.status == 'Deployed':
domain.status = 'inProgress'
domain.save()
a = middware.DomainManage()
a.enable(domainId=domain.domain_id)
else:
msg = _("%s status is %s, can not do this action") % (
domain.domain_name, _(domain.status))
messages.warning(request, msg)
except Exception:
obj = self.table.get_object_by_id(obj_id)
name = self.table.get_object_display(obj)
msg = _('Unable to enable domain %s') % name
LOG.info(msg)
messages.error(request, msg)
exceptions.handle(request, msg)
redirect = reverse(self.redirect_url)
raise exceptions.Http302(redirect, message=msg)
def form_valid(self, form):
try:
handled = form.handle(self.request, form.cleaned_data)
except Exception:
handled = None
exceptions.handle(self.request)
if handled:
domain_id = self.kwargs["domain_id"]
access_type = form.cleaned_data["type"]
control_type = form.cleaned_data['access_type']
refer = form.cleaned_data["refer"]
white_list = form.cleaned_data["white_list"]
black_list = form.cleaned_data["black_list"]
forbid_ip = form.cleaned_data["forbid_ip"]
domain = Domain.objects.get(pk=domain_id)
if domain.status == 'Deployed':
modify = middware.DomainManage()
if control_type == 'white':
if forbid_ip == u'':
visitControlRule = middware.domainApi.VisitControlRule(
pathPattern=str(access_type),
allowNullReferer=refer,
validReferers=str(white_list).strip('\r\n').split(
'\r\n'))
else:
visitControlRule = middware.domainApi.VisitControlRule(
pathPattern=str(access_type),
allowNullReferer=refer,
validReferers=str(white_list).strip('\r\n').split(
'\r\n'),
forbiddenIps=str(forbid_ip).strip('\r\n').split(
'\r\n'))
else:
if forbid_ip == u'':
visitControlRule = middware.domainApi.VisitControlRule(
pathPattern=str(access_type),
invalidReferers=str(black_list).strip(
'\r\n').split('\r\n'))
else:
visitControlRule = middware.domainApi.VisitControlRule(
pathPattern=str(access_type),
invalidReferers=str(black_list).strip(
'\r\n').split('\r\n'),
forbiddenIps=str(forbid_ip).strip('\r\n').split(
'\r\n'))
domain_class = middware.domainApi.Domain(
domainId=domain.domain_id,
visitControlRules=[visitControlRule])
ret = modify.modify(domain_class)
if ret.getMsg() == 'success':
msg = _("modify successfully")
messages.success(self.request, msg)
access_id = self.kwargs['access_id']
access = AccessControl.objects.get(pk=access_id)
access.pathPattern = access_type
access.allowNullReffer = refer
access.validRefers = white_list
access.invalidRefers = black_list
access.forbiddenIps = forbid_ip
access.save()
else:
messages.error(self.request, ret.getMsg())
redirect_url = self.get_success_url()
return HttpResponseRedirect(redirect_url)
else:
msg = _("%s status is %s, can not do this action") % (
domain.domain_name, _(domain.status))
messages.warning(self.request, msg)
redirect_url = self.get_success_url()
return HttpResponseRedirect(redirect_url)
def _get_domain(self):
domain_list = middware.DomainManage()
return domain_list.listAll()
def get_cdn():
cdn_list = middware.DomainManage()
return cdn_list.listAll()
