def edit_user(request):
if request.method == 'GET':
did = request.GET.get('id', None)
data = Role.objects.filter(deleted_at__isnull=True)
li_st = []
for item in data:
di_ct = {"id": item.id, 'name': item.name}
li_st.append(di_ct)
if did:
user = User.objects.get(id=did)
context = {'id': did, 'profile': user, "role": li_st}
else:
context = {"role": li_st}
return render(request, 'user/edit_user.html', context)
elif request.method == 'POST':
user = user_get(request)
did = request.POST.get('id')
data = {
"username": request.POST.get("username"),
"name": request.POST.get("name"),
"sex": request.POST.get("sex"),
"phone": request.POST.get("phone"),
"email": request.POST.get("email"),
"card_id": request.POST.get("card_id"),
"home_address": request.POST.get("home_address"),
"desc": request.POST.get("desc", None),
}
if did:
if User.objects.filter(phone=data["phone"],
deleted_by_id__isnull=True).exclude(id=did):
return JsonResponse({"code": 1, "msg": "手机号已存在"})
if User.objects.filter(email=data["email"],
deleted_by_id__isnull=True).exclude(id=did):
return JsonResponse({"code": 1, "msg": "邮箱已存在"})
User.objects.filter(id=did).update(**data)
data = {"code": 0, "msg": "用户资料修改成功~"}
else:
data["password"] = request.POST.get("password")
if User.objects.filter(username=data["username"]).first():
return JsonResponse({"code": 1, "msg": "用户名已存在"})
if User.objects.filter(phone=data["phone"],
deleted_by_id__isnull=True).first():
return JsonResponse({"code": 1, "msg": "手机号已存在"})
if User.objects.filter(email=data["email"],
deleted_by_id__isnull=True).first():
return JsonResponse({"code": 1, "msg": "邮箱已存在"})
User.objects.create_user(created_by=user, **data)
data = {"code": 0, "msg": "用户添加成功~"}
return JsonResponse(data)
elif request.method == "DELETE":
user = user_get(request)
request_data = QueryDict(request.body)
did = request_data.get("id").split(",")
User.objects.filter(id__in=did).update(deleted_at=human_datetime(),
deleted_by=user,
is_active=0)
data = {"code": 0, "msg": "账号删除成功~"}
return JsonResponse(data)
def domains_add(request):
request_data = QueryDict(request.body)
did = request_data.get("id", None)
user = user_get(request)
if request.method == "GET":
data = Api.objects.filter().values('id', 'name')
return render(request, "domains/domains_add.html", {'api': data})
if request.method == "POST":
id = request.POST.get("id")
domain = request.POST.get("domain")
obj = Domains.objects.filter(domain=domain)
if obj.count() == 0:
api = Api.objects.get(id=id)
data = Ali_Add_Domain(api.key, api.secret, api.region, domain)
if data['code'] == 0:
data = json.loads(data['data'])
dns1 = data['DnsServers']['DnsServer'][0]
dns2 = data['DnsServers']['DnsServer'][1]
Domains.objects.create(api=api,
domain=domain,
dns1=dns1,
dns2=dns2)
data = {"code": 0, "msg": "添加域名成功~"}
else:
data = {"code": 1, "msg": "添加域名失败~"}
return JsonResponse(data)
elif request.method == "DELETE":
id = request.POST.get('id')
Domains.objects.get(id=id).delete()
data = {"code": 0, "msg": "域名删除成功~"}
return JsonResponse(data)
def role(request):
user = user_get(request)
request_data = QueryDict(request.body)
d_id = request_data.get('id', None)
name = request_data.get('name', None)
if request.method == "GET":
return render(request, 'user/role.html')
elif request.method == "POST":
if Role.objects.filter(name=name,
deleted_by__id__isnull=True).exists():
data = {"code": 1, "msg": "角色已存在，创建失败~"}
else:
Role.objects.create(name=name, created_by=user)
data = {"code": 0, "msg": "角色创建成功~"}
return JsonResponse(data)
elif request.method == "PUT":
if Role.objects.filter(name=name,
deleted_by__id__isnull=True).exists():
data = {"code": 1, "msg": "角色已存在，修改失败~"}
else:
Role.objects.filter(id=d_id).update(name=name)
data = {"code": 0, "msg": "角色修改成功~"}
return JsonResponse(data)
elif request.method == "DELETE":
Role.objects.filter(id__in=d_id.split(",")).update(
deleted_at=human_datetime(), deleted_by=user)
data = {"code": 0, "msg": "删除角色成功"}
return JsonResponse(data)
def template_edit(request):
request_data = QueryDict(request.body)
user = user_get(request)
did = request_data.get("id", None)
if request.method == "GET":
did = request.GET.get("id", None)
if did:
data = Exec.objects.get(id=did)
else:
data = ""
return render(request, "exec/template_edit.html", {"data": data})
if request.method == "POST":
data = {
"name": request_data.get('name'),
"types": request_data.get('types'),
"body": request_data.get('body'),
"desc": request_data.get('desc'),
}
if did:
Exec.objects.filter(id=did).update(**data)
data = {"code": 0, "msg": "模板修改成功。"}
else:
Exec.objects.create(created_by=user, **data)
data = {"code": 0, "msg": "添加模板成功。"}
return JsonResponse(data)
elif request.method == "DELETE":
Exec.objects.filter(id__in=did.split(',')).update(
deleted_at=human_datetime(), deleted_by=user)
data = {"code": 0, "msg": "模板删除成功~"}
return JsonResponse(data)
def edit_host(request):
if request.method == "GET":
did = request.GET.get("id", None)
if did:
data = Host.objects.get(id=did)
else:
data = ""
return render(request, "host/edit_host.html", {"host": data})
elif request.method == "POST":
user = user_get(request)
did = request.POST.get("id", None)
password = request.POST.get("password", None)
data = {
"types": request.POST.get("types"),
"system": request.POST.get("system"),
"name": request.POST.get("name"),
"username": request.POST.get("username"),
"hostname": request.POST.get("hostname"),
"port": request.POST.get("port"),
"pkey": request.POST.get("pkey"),
"desc": request.POST.get("desc"),
}
valid = valid_ssh(data['hostname'], data['port'], data['username'], password=password, pkey=data['pkey'])
if valid[0] is False:
data = {"code": 1, "msg": valid[2]}
return JsonResponse(data)
if did:
Host.objects.filter(id=did).update(**data)
data = {"code": 0, "msg": "修改主机成功~"}
elif Host.objects.filter(hostname=data['hostname'], deleted_by_id__isnull=True).exists():
data = {"code": 1, "msg": "添加失败,主机已存在~"}
else:
Host.objects.create(created_by=user, **data)
data = {"code": 0, "msg": "添加主机成功~"}
return JsonResponse(data)
def contact_edit(request):
request_data = QueryDict(request.body)
did = request_data.get('id', None)
user = user_get(request)
if request.method == "GET":
did = request.GET.get('id')
if did:
data = Contact.objects.filter(id=did).first()
else:
data = ""
return render(request, "alarm/contact_edit.html", {"data": data})
elif request.method == "POST":
data = {
"name": request_data.get("name"),
"phone": request_data.get("phone"),
"email": request_data.get("email"),
"ding": request_data.get("ding"),
"wx_token": request_data.get("wx_token"),
"qy_wx": request_data.get("qy_wx"),
}
if did:
Contact.objects.filter(id=did).update(**data)
data = {"code": 1, "msg": "联系人修改成功~"}
else:
Contact.objects.create(created_by=user, **data)
data = {"code": 0, "msg": "联系人添加成功~"}
return JsonResponse(data)
elif request.method == "DELETE":
Contact.objects.filter(id__in=did.split(',')).update(
deleted_at=human_datetime(), deleted_by=user)
data = {"code": 0, "msg": "联系人删除成功"}
return JsonResponse(data)
def domains(request):
user = user_get(request)
if request.method == "GET":
data = Domains.objects.filter(deleted_by__id__isnull=True)
data = {"data": data}
return render(request, "domains/domains.html", data)
elif request.method == "SYNC":
request_data = QueryDict(request.body)
id = request_data.get("id")
domain = Domains.objects.get(id=id)
data = Ali_Parsing(domain.api.key, domain.api.secret,
domain.api.region, domain.domain)
if data['code'] == 0:
data = json.loads(data['data'])
for item in data['DomainRecords']['Record']:
dict = {}
dict['RR'] = item['RR']
dict['Line'] = item['Line']
dict['Type'] = item['Type']
dict['Value'] = item['Value']
dict['RecordId'] = item['RecordId']
dict['TTL'] = item['TTL']
dict['domain_id'] = domain.id
if "Priority" in item:
dict['Priority'] = item['Priority']
else:
dict['Priority'] = None
Parsing.objects.update_or_create(RecordId=item['RecordId'],
defaults=dict,
created_by=user)
data = {"code": 0, "msg": "域名解析同步成功~"}
else:
data = {"code": 1, "msg": "域名解析同步失败~"}
return JsonResponse(data)
def pod(request):
user = user_get(request)
hostname = request.GET.get('hostname')
namespace = request.GET.get("namespace")
pod_name = request.GET.get("pod_name")
containers = request.GET.get("containers").split(',') # 返回 nginx1,nginx2，转成一个列表方便前端处理
# 认证类型和token，用于传递到websocket，websocket根据sessionid获取token，让websocket处理连接k8s认证用
connect = {'hostname': hostname, 'username': user, 'namespace': namespace, 'pod_name': pod_name, 'containers': containers}
return render(request, 'webssh/pod.html', {'connect': connect})
def get_statefulset(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
apps_api = client.AppsV1Api()
namespace = request.GET.get("namespace")
if request.method == "GET":
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for sts in apps_api.list_namespaced_stateful_set(namespace).items:
dict = {}
dict["name"] = sts.metadata.name
dict["namespace"] = sts.metadata.namespace
dict["replicas"] = sts.spec.replicas
dict["selector"] = sts.spec.selector.match_labels
dict["service_name"] = sts.spec.service_name
dict["ready_replicas"] = ("0"
if sts.status.ready_replicas is None
else sts.status.ready_replicas)
# current_replicas = sts.status.current_replicas
containers = {}
for c in sts.spec.template.spec.containers:
containers[c.name] = c.image
dict["containers"] = containers
dict["labels"] = sts.metadata.labels
dict["create_time"] = dt_format(
sts.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
namespace = request_data.get('namespace')
try:
apps_api.delete_namespaced_stateful_set(name, namespace)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
def get_pvc(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
core_api = client.CoreV1Api()
namespace = request.GET.get("namespace")
if request.method == "GET":
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for pvc in core_api.list_namespaced_persistent_volume_claim(
namespace).items:
dict = {}
dict["name"] = pvc.metadata.name
dict["namespace"] = pvc.metadata.namespace
dict["labels"] = pvc.metadata.labels
dict["storage_class_name"] = pvc.spec.storage_class_name
dict["access_modes"] = pvc.spec.access_modes
dict["capacity"] = (pvc.status.capacity
if pvc.status.capacity is None else
pvc.status.capacity["storage"])
dict["volume_name"] = pvc.spec.volume_name
dict["status"] = pvc.status.phase
dict["create_time"] = dt_format(
pvc.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
namespace = request_data.get("namespace")
try:
core_api.delete_namespaced_persistent_volume_claim(name, namespace)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
def get_jobs(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
batch_api = client.BatchV1Api()
namespace = request.GET.get("namespace")
if request.method == "GET":
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for job in batch_api.list_namespaced_job(namespace).items:
dict = {}
dict["name"] = job.metadata.name
dict["namespace"] = job.metadata.namespace
# dict["desired_number"] = ds.status.desired_number_scheduled
# dict["available_number"] = ds.status.number_available
# dict["selector"] = ds.spec.selector.match_labels
# containers = {}
# for c in ds.spec.template.spec.containers:
# containers[c.name] = c.image
# dict["containers"] = containers
dict["labels"] = job.metadata.labels
dict["create_time"] = dt_format(
job.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
try:
batch_api.delete_namespaced_cron_job(name, namespace)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
def get_cronjobs(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
batch_api = client.BatchV2alpha1Api()
namespace = request.GET.get("namespace")
if request.method == "GET":
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for cj in batch_api.list_namespaced_cron_job(namespace).items:
dict = {}
dict["name"] = cj.metadata.name
dict["namespace"] = cj.metadata.namespace
dict["schedule"] = cj.spec.schedule
if cj.status.last_schedule_time:
dict["lastScheduleTime"] = dt_format(
cj.status.last_schedule_time)
else:
dict["lastScheduleTime"] = ""
print(cj.status.last_schedule_time)
dict["create_time"] = dt_format(cj.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
namespace = request_data.get("namespace")
try:
batch_api.delete_namespaced_cron_job(name, namespace)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
def yaml_json_add(request):
user = user_get(request)
hostname = request.POST.get('hostname')
auth_config(user, hostname)
core_api = client.CoreV1Api() # namespace,pod,service,pv,pvc
apps_api = client.AppsV1Api() # deployment
batch1_api = client.BatchV1Api()
batch2_api = client.BatchV2alpha1Api()
networking_api = client.NetworkingV1beta1Api() # ingress
storage_api = client.StorageV1Api() # storage_class
namespace = request.POST.get('namespace', None)
resource = request.POST.get('resource', None)
name = request.POST.get('name', None)
types = request.POST.get('types')
if types == "yaml":
body = request.POST.get('yaml', None)
body = yaml.safe_load(body)
else:
body = request.POST.get('json', None)
try:
if body['kind'] == "Namespace":
core_api.create_namespace(body)
elif body['kind'] == "Deployment":
apps_api.create_namespaced_deployment(namespace, body)
elif body['kind'] == "DaemonSet":
apps_api.create_namespaced_daemon_set(namespace, body)
elif body['kind'] == "StatefulSet":
apps_api.create_namespaced_stateful_set(namespace, body)
elif body['kind'] == "Service":
core_api.create_namespaced_service(namespace, body)
elif body['kind'] == "Pod":
core_api.create_namespaced_pod(namespace, body)
elif body['kind'] == "Ingress":
networking_api.create_namespaced_ingress(namespace, body)
elif body['kind'] == "PersistentVolume":
core_api.create_persistent_volume(body)
elif body['kind'] == "PersistentVolumeClaim":
core_api.create_namespaced_persistent_volume_claim(namespace, body)
elif body['kind'] == "ConfigMap":
core_api.create_namespaced_config_map(namespace, body)
elif body['kind'] == "Secret":
core_api.create_namespaced_secret(namespace, body)
elif body['kind'] == "CronJob":
batch2_api.create_namespaced_cron_job(namespace, body)
elif body['kind'] == "Job":
batch1_api.create_namespaced_job(namespace, body)
data = {"code": 0, "msg": f"{body['kind']}创建成功"}
return data
except Exception as e:
data = error(e)
return data
def group_edit(request):
request_data = QueryDict(request.body)
did = request_data.get('id', None)
user = user_get(request)
if request.method == "GET":
did = request.GET.get("id")
data = Contact.objects.filter(deleted_by__id__isnull=True)
if data:
li_st = []
for item in data:
di_ct = {"value": item.id, "title": item.name}
li_st.append(di_ct)
else:
li_st = ""
if did:
data = Group.objects.filter(id=did).first()
value = []
for item in data.contacts.all():
value.append(item.id)
data.contact = li_st
data.values = value
else:
data = {"contact": li_st, "values": ""}
return render(request, "alarm/group_edit.html", {"data": data})
if request.method == "POST":
data = {
"name": request_data.get("name"),
"desc": request_data.get("desc"),
}
contacts = json.loads(request_data.get("contacts"))
li_st = []
for item in contacts:
li_st.append(int(item['value']))
print(li_st)
if did:
contacts = Contact.objects.filter(id__in=li_st)
print(contacts)
data = Group.objects.filter(id=did)
data.contacts.add(*li_st)
data.update(**data)
data.save()
print(data, "1")
# data.contacts.add(*contacts)
# data.save()
data = {"code": 0, "msg": "联系组修改成功~"}
else:
data = Group.objects.create(created_by=user, **data)
data.contacts.add(*contacts)
data = {"code": 0, "msg": "联系组添加失败~"}
return JsonResponse(data)
def get_secret(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
core_api = client.CoreV1Api()
namespace = request.GET.get("namespace")
if request.method == "GET":
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for secret in core_api.list_namespaced_secret(namespace).items:
dict = {}
dict["name"] = secret.metadata.name
dict["namespace"] = secret.metadata.namespace
dict["data_length"] = ("空" if secret.data is None else len(
secret.data))
dict["create_time"] = dt_format(
secret.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
namespace = request_data.get("namespace")
try:
core_api.delete_namespaced_secret(name, namespace)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
def get_node(request):
# 命名空间选择和命名空间表格使用
if request.method == "GET":
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
core_api = client.CoreV1Api()
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for node in core_api.list_node_with_http_info()[0].items:
dict = {}
dict["name"] = node.metadata.name
dict["labels"] = node.metadata.labels
status = node.status.conditions[-1].status
if status:
dict["status"] = "Ready"
else:
dict["status"] = status
dict["scheduler"] = ("是" if node.spec.unschedulable is None
else "否")
dict["cpu"] = node.status.capacity['cpu']
dict["memory"] = node.status.capacity['memory']
dict["kebelet_version"] = node.status.node_info.kubelet_version
dict[
"cri_version"] = node.status.node_info.container_runtime_version
dict["create_time"] = dt_format(
node.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
def get_menu(request):
user = user_get(request)
if user.is_superuser:
menuInfo = menuIn(user.is_superuser)
else:
menuInfo = menuIn(user.username)
homeInfo = {"title": "首页", "href": "home.html"}
logoInfo = {
"title": "运维管理平台",
"image": "/static/layuimini/images/logo.png",
"href": ""
}
systemInit = {
"homeInfo": homeInfo,
"logoInfo": logoInfo,
"menuInfo": menuInfo,
}
return JsonResponse(systemInit)
def get_key(request):
if request.method == "GET":
data = Setting.objects.all()
elif request.method == "POST":
user = user_get(request)
public_key = request.POST.get("public_key")
private_key = request.POST.get("private_key")
obj_public_key = Setting.objects.update_or_create(
key="public_key", defaults={"value": public_key}, created_by=user)
print(obj_public_key)
obj_private_key = Setting.objects.update_or_create(
key="private_key",
defaults={"value": private_key},
created_by=user)
print(obj_private_key)
data = {"code": 0, "msg": "修改成功."}
return JsonResponse(data)
def host(request):
if request.method == "GET":
data = Host.objects.all()
types, system = [], []
for item in data:
types.append(item.types)
system.append(item.system)
context = {"types": list(set(types)), "system": list(set(system))}
return render(request, "host/host.html", context)
elif request.method == "DELETE":
user = user_get(request)
request_data = QueryDict(request.body)
did = request_data.get("id").split(",")
Host.objects.filter(id__in=did).update(deleted_at=human_datetime(), deleted_by=user)
data = {"code": 0, "msg": "主机删除成功~"}
return JsonResponse(data)
elif request.method == "POST":
key = request.FILES.get("file")
data = key.read()
data = {"code": 0, "msg": "上传成功", "data": data.decode('utf-8')}
return JsonResponse(data)
def get_k8s(request):
if request.method == "GET":
try:
user = user_get(request)
hostname = request.GET.get('hostname')
user = User.objects.get(username=user)
host = []
if user.is_superuser:
data = K8s.objects.all()
for item in data:
dict = {}
dict['hostname'] = item.hostname.hostname
host.append(dict)
if hostname == "null":
hostname = host[0]["hostname"]
auth_config(user, hostname)
else:
data = Auth.objects.filter(user_id=user.id)
for auth in data:
dict = {}
dict['hostname'] = auth.hostname.hostname.hostname
host.append(dict)
if hostname == "null":
hostname = host[0]["hostname"]
auth_config(user, hostname)
core_api = client.CoreV1Api()
namespace = []
for ns in core_api.list_namespace().items:
dict = {}
dict["name"] = ns.metadata.name
namespace.append(dict)
data = {
"code": 0,
"msg": "ok",
"hostname": host,
"namespace": namespace
}
except Exception as e:
data = error(e)
return JsonResponse(data)
def edit_k8s(request):
user = user_get(request)
request_data = QueryDict(request.body)
d_id = request_data.get("id", None)
if request.method == "GET":
d_id = request.GET.get("id", None)
if d_id:
data = K8s.objects.get(id=d_id)
else:
data = ""
return render(request, "k8s/edit_k8s.html", {"data": data})
elif request.method == "POST":
data = {
"name": request_data.get('name'),
"ca": request_data.get('ca'),
"config": request_data.get("config"),
"desc": request_data.get('desc'),
}
hostname = Host.objects.get(hostname=request_data.get('hostname'),
deleted_by__id__isnull=True)
if d_id:
K8s.objects.filter(id=d_id).update(hostname=hostname, **data)
data = {"code": 0, "msg": "修改成功~"}
else:
if K8s.objects.filter(hostname=hostname,
deleted_by__id__isnull=True).exists():
data = {"code": 1, "msg": "添加失败,主机已存在~"}
else:
K8s.objects.create(created_by=user, hostname=hostname, **data)
data = {"code": 0, "msg": "主机添加成功~"}
return JsonResponse(data)
elif request.method == "DELETE":
K8s.objects.filter(id__in=d_id.split(",")).update(
deleted_at=human_datetime(), deleted_by=user)
data = {"code": 0, "msg": "删除成功."}
return JsonResponse(data)
def get_service(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
core_api = client.CoreV1Api()
namespace = request.GET.get("namespace")
if request.method == "GET":
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for service in core_api.list_namespaced_service(namespace).items:
dict = {}
dict["name"] = service.metadata.name
dict["namespace"] = service.metadata.namespace
dict["labels"] = service.metadata.labels
dict["type"] = service.spec.type
dict["cluster_ip"] = service.spec.cluster_ip
dict["selector"] = service.spec.selector
ports = []
for p in service.spec.ports: # 不是序列，不能直接返回
port_name = p.name
port = p.port
target_port = p.target_port
protocol = p.protocol
node_port = ""
if dict["type"] == "NodePort":
node_port = " <br> NodePort: %s" % p.node_port
port = {
'port_name': port_name,
'port': port,
'protocol': protocol,
'target_port': target_port,
'node_port': node_port
}
ports.append(port)
dict["ports"] = ports
# 确认是否关联Pod
for ep in core_api.list_namespaced_endpoints(namespace).items:
if ep.metadata.name == dict["name"] and ep.subsets is None:
dict["endpoint"] = "未关联"
else:
dict["endpoint"] = "已关联"
dict["create_time"] = dt_format(
service.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
try:
core_api.delete_namespaced_service(name, namespace)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
def get_ingress(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
networking_api = client.NetworkingV1beta1Api()
namespace = request.GET.get("namespace")
if request.method == "GET":
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for ing in networking_api.list_namespaced_ingress(namespace).items:
dict = {}
dict["name"] = ing.metadata.name
dict["namespace"] = ing.metadata.namespace
dict["service"] = "None"
# dict["http_hosts"] = "None"
for h in ing.spec.rules:
host = h.host
path = ("/" if h.http.paths[0].path is None else
h.http.paths[0].path)
service_name = h.http.paths[0].backend.service_name
service_port = h.http.paths[0].backend.service_port
http_hosts = {
'host': host,
'path': path,
'service_name': service_name,
'service_port': service_port
}
dict["http_hosts"] = http_hosts
# dict["https_hosts"] = "None"
if ing.spec.tls is None:
https_hosts = ing.spec.tls
else:
for tls in ing.spec.tls:
host = tls.hosts[0]
secret_name = tls.secret_name
https_hosts = {
'host': host,
'secret_name': secret_name
}
dict["https_hosts"] = https_hosts
dict["labels"] = ing.metadata.labels
dict["create_time"] = dt_format(
ing.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
namespace = request_data.get("namespace")
try:
networking_api.delete_namespaced_ingress(name, namespace)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
def get_deployment(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
apps_api = client.AppsV1Api()
namespace = request.GET.get("namespace")
if request.method == "GET":
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for dp in apps_api.list_namespaced_deployment(namespace).items:
dict = {}
dict["name"] = dp.metadata.name
dict["namespace"] = dp.metadata.namespace
dict["replicas"] = dp.spec.replicas
dict["available_replicas"] = (
0 if dp.status.available_replicas is None else
dp.status.available_replicas)
dict["labels"] = dp.metadata.labels
dict["selector"] = dp.spec.selector.match_labels
if len(dp.spec.template.spec.containers) > 1:
images = ""
n = 1
for c in dp.spec.template.spec.containers:
status = ("运行中" if dp.status.conditions[0].status
== "True" else "异常")
image = c.image
images += "[%s]: %s / %s" % (n, image, status)
images += "<br>"
n += 1
else:
status = ("运行中" if dp.status.conditions[0].status == "True"
else "异常")
image = dp.spec.template.spec.containers[0].image
images = "%s / %s" % (image, status)
dict["images"] = images
dict["create_time"] = dt_format(dp.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
namespace = request_data.get("namespace")
try:
apps_api.delete_namespaced_deployment(name, namespace)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "REPLICAS":
request_data = QueryDict(request.body)
name = request_data.get("name")
replicas = request_data.get('replicas')
try:
body = apps_api.read_namespaced_deployment(name, namespace)
body.spec.replicas = int(replicas)
apps_api.replace_namespaced_deployment(name, namespace, body)
data = {"code": 0, "msg": "修改成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
def schedule_edit(request):
user = user_get(request)
request_data = QueryDict(request.body)
did = request_data.get("id", None)
if request.method == "GET":
did = request.GET.get("id")
if did:
data = Schedule.objects.get(id=did)
data.targets = ','.join(eval(data.targets))
data.rst_notify = eval(data.rst_notify)
else:
data = ""
return render(request, "exec/schedule_edit.html", {"data": data})
elif request.method == "POST":
data = {
'name': request.POST.get("name"),
'types': request.POST.get("types"),
'command': request.POST.get("command"),
'targets': request.POST.get("targets").split(","),
'desc': request.POST.get("desc"),
'rst_notify': {
"mode": request_data.get('rst_notify.mode'),
'value': request_data.get('rst_notify.value')
}
}
trigger = request.POST.get("trigger")
if did:
if trigger == "interval":
interval = request.POST.get("interval")
Schedule.objects.filter(id=did).update(trigger=trigger,
trigger_args=interval,
**data)
elif trigger == "date":
date = request.POST.get("date")
Schedule.objects.filter(id=did).update(trigger=trigger,
trigger_args=date,
**data)
elif trigger == "cron":
cron = request.POST.get("cron")
Schedule.objects.filter(id=did).update(trigger=trigger,
trigger_args=cron,
**data)
obj = Schedule.objects.filter(id=did).first()
if obj and obj.is_active:
message = {'id': obj.id, 'action': 'modify'}
message.update({
'trigger': obj.trigger,
'trigger_args': obj.trigger_args,
'command': obj.command,
'targets': obj.targets
})
rds_cli = get_redis_connection()
rds_cli.lpush(settings.SCHEDULE_KEY, json.dumps(message))
data = {"code": 0, "msg": "类别修改成功~"}
else:
if trigger == "interval":
interval = request.POST.get("interval")
Schedule.objects.create(created_by=user,
trigger=trigger,
trigger_args=interval,
**data)
elif trigger == "date":
date = request.POST.get("date")
Schedule.objects.create(created_by=user,
trigger=trigger,
trigger_args=date,
**data)
elif trigger == "cron":
cron = request.POST.get("cron")
Schedule.objects.create(created_by=user,
trigger=trigger,
trigger_args=cron,
**data)
data = {"code": 0, "msg": "任务添加成功~"}
return JsonResponse(data)
elif request.method == "DELETE":
obj = Schedule.objects.filter(id=did).first()
if obj:
if obj.is_active:
data = {"code": 1, "msg": "该任务在运行中，请先停止任务再尝试删除"}
else:
Schedule.objects.filter(id=did).update(
deleted_at=human_datetime(), deleted_by=user)
data = {"code": 0, "msg": "任务删除成功"}
return JsonResponse(data)
elif request.method == "PUT":
obj = Schedule.objects.filter(id=did).first()
if obj:
if obj.is_active:
obj.is_active = 0
obj.save()
message = {'id': did, 'action': 'remove'}
data = {"code": 1, "msg": "任务已停止"}
else:
message = {'id': did, 'action': 'add'}
message.update({
'trigger': obj.trigger,
'trigger_args': obj.trigger_args,
'command': obj.command,
'targets': obj.targets
})
obj.is_active = 1
obj.save()
data = {"code": 0, "msg": "任务启动成功"}
rds_cli = get_redis_connection()
rds_cli.lpush(settings.SCHEDULE_KEY, json.dumps(message))
return JsonResponse(data)
def get_namespace(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
core_api = client.CoreV1Api()
if request.method == "GET":
list = []
res = []
try:
for ns in core_api.list_namespace().items:
dict = {}
dict["name"] = ns.metadata.name
dict["labels"] = ns.metadata.labels
dict["phase"] = ns.status.phase
dict["create_time"] = dt_format(ns.metadata.creation_timestamp)
list.append(dict)
if request.GET.get("pageIndex"):
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
else:
res = list
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
try:
core_api.delete_namespace(name)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "ADD":
request_data = QueryDict(request.body)
name = request_data.get("name")
labels = request_data.get("labels")
try:
dict = {}
if not labels:
pass
else:
labels = request_data.get("labels").split(",")
for label in labels:
i, b = label.split(":")
dict[f"{i}"] = b
body = {
"apiVersion": "v1",
"kind": "Namespace",
"metadata": {
"name": name,
"labels": dict
}
}
core_api.create_namespace(body)
data = {"code": 0, "msg": "添加成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "EDIT":
request_data = QueryDict(request.body)
name = request_data.get("name")
labels = request_data.get("labels")
try:
body = core_api.read_namespace(name)
dict = {}
if not labels:
body.metadata.labels = None
else:
labels = request_data.get("labels").split(",")
for label in labels:
i, b = label.split(":")
dict[f"{i}"] = b
body.metadata.labels = dict
core_api.replace_namespace(name, body) # 全局更新
# core_api.patch_namespace(name=name, body=body) # 局部更新
data = {"code": 0, "msg": "修改成功.", "data": dict}
except Exception as e:
data = error(e)
return JsonResponse(data)
def get_pv(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
core_api = client.CoreV1Api()
if request.method == "GET":
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for pv in core_api.list_persistent_volume().items:
dict = {}
dict["name"] = pv.metadata.name
dict["capacity"] = pv.spec.capacity["storage"]
dict["access_modes"] = pv.spec.access_modes
dict[
"reclaim_policy"] = pv.spec.persistent_volume_reclaim_policy
dict["status"] = pv.status.phase
if pv.spec.claim_ref is not None:
pvc_ns = pv.spec.claim_ref.namespace
pvc_name = pv.spec.claim_ref.name
dict["pvc"] = "%s / %s" % (pvc_ns, pvc_name)
else:
dict["pvc"] = "未绑定"
dict["tsorage_class"] = pv.spec.storage_class_name
dict["create_time"] = dt_format(pv.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
try:
core_api.delete_persistent_volume(name)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "POST":
name = request.POST.get("name", None)
capacity = request.POST.get("capacity", None)
access_mode = request.POST.get("access_mode", None)
storage_type = request.POST.get("storage_type", None)
server_ip = request.POST.get("server_ip", None)
mount_path = request.POST.get("mount_path", None)
body = client.V1PersistentVolume(
api_version="v1",
kind="PersistentVolume",
metadata=client.V1ObjectMeta(name=name),
spec=client.V1PersistentVolumeSpec(
capacity={'storage': capacity},
access_modes=[access_mode],
nfs=client.V1NFSVolumeSource(server=server_ip,
path="/ifs/kubernetes/%s" %
mount_path)))
try:
core_api.create_persistent_volume(body=body)
data = {"code": 0, "msg": "创建成功"}
except Exception as e:
data = error(e)
return JsonResponse(data)
def get_pod(request):
user = user_get(request)
hostname = request.GET.get('hostname')
auth_config(user, hostname)
core_api = client.CoreV1Api()
if request.method == "GET":
namespace = request.GET.get("namespace")
pageIndex = request.GET.get("pageIndex")
pageSize = request.GET.get("pageSize")
list = []
res = []
try:
for pods in core_api.list_namespaced_pod(namespace).items:
dict = {}
dict["name"] = pods.metadata.name
dict["namespace"] = pods.metadata.namespace
dict["pod_ip"] = pods.status.pod_ip
dict["labels"] = pods.metadata.labels
containers = [] # [{},{},{}]
status = "None"
# 只为None说明Pod没有创建（不能调度或者正在下载镜像）
if pods.status.container_statuses is None:
status = pods.status.conditions[-1].reason
print(status)
else:
for c in pods.status.container_statuses:
c_name = c.name
c_image = c.image
# 获取重启次数
restart_count = c.restart_count
# 获取容器状态
c_status = "None"
if c.ready is True:
c_status = "Running"
elif c.ready is False:
if c.state.waiting is not None:
c_status = c.state.waiting.reason
elif c.state.terminated is not None:
c_status = c.state.terminated.reason
elif c.state.last_state.terminated is not None:
c_status = c.last_state.terminated.reason
c = {
'c_name': c_name,
'c_image': c_image,
'restart_count': restart_count,
'c_status': c_status
}
containers.append(c)
dict["containers"] = containers
dict["phase"] = pods.status.phase
dict["create_time"] = dt_format(
pods.metadata.creation_timestamp)
list.append(dict)
pageInator = Paginator(list, pageSize)
context = pageInator.page(pageIndex)
for item in context:
res.append(item)
data = {
"code": 0,
"msg": "ok",
"DataCount": len(list),
"data": res
}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "DELETE":
request_data = QueryDict(request.body)
name = request_data.get("name")
namespace = request_data.get("namespace")
try:
core_api.delete_namespaced_pod(name, namespace)
data = {"code": 0, "msg": "删除成功."}
except Exception as e:
data = error(e)
return JsonResponse(data)
elif request.method == "LOG":
request_data = QueryDict(request.body)
name = request_data.get("name", None)
namespace = request_data.get("namespace", None)
# 目前没有对Pod多容器处理
try:
log_text = core_api.read_namespaced_pod_log(name=name,
namespace=namespace,
tail_lines=500)
if len(log_text) == 0:
data = {"code": 0, "msg": "获取日志成功", "data": "没有日志！"}
else:
data = {"code": 0, "msg": "获取日志成功", "data": log_text}
except Exception as e:
data = error(e)
return JsonResponse(data)
def parsing_edit(request):
request_data = QueryDict(request.body)
user = user_get(request)
did = request_data.get("id", None)
if request.method == "GET":
dom = Domains.objects.filter(deleted_by__id__isnull=True)
did = request.GET.get('id', None)
if did:
data = Parsing.objects.get(id=did)
else:
data = ""
return render(request, "domains/parsing_edit.html", {
"data": data,
"domain": dom
})
elif request.method == "POST":
data = {
"RR": request_data.get("RR"),
"Type": request_data.get("Type"),
"Value": request_data.get("Value"),
"TTL": request_data.get("TTL"),
"Line": request_data.get("Line"),
"Priority": request_data.get("Priority", None),
"RecordId": request_data.get("RecordId", None),
}
pars = Domains.objects.get(id=request_data.get("domain"))
if did:
api_key = Ali_Edit_Parsing(pars.api.key, pars.api.secret,
pars.api.region, **data)
if api_key['code'] == 0:
Parsing.objects.filter(id=did).update(**data)
data = {"code": 0, "msg": "域名解析修改成功~"}
else:
data = {"code": 0, "msg": "域名解析失败~"}
else:
api_key = Ali_Edit_Parsing(pars.api.key, pars.api.secret,
pars.api.region, pars.domain, **data)
if api_key['code'] == 0:
data['RecordId'] = json.loads(api_key['data'])['RecordId']
Parsing.objects.create(created_by=user, **data, domain=pars)
data = {"code": 0, "msg": "域名解析添加成功~"}
else:
data = {"code": 0, "msg": "域名解析失败~"}
return JsonResponse(data)
elif request.method == "DELETE":
Pars = Parsing.objects.filter(id=did)
data = Ali_Del_Parsing(Pars.first().domain.api.key,
Pars.first().domain.api.secret,
Pars.first().domain.api.region,
Pars.first().RecordId)
if data['code'] == 0:
Pars.update(deleted_at=human_datetime(), deleted_by=user)
data = {"code": 0, "msg": "域名解析同步删除成功~"}
else:
Pars.update(deleted_at=human_datetime(), deleted_by=user)
data = {"code": 0, "msg": "域名解析本地删除成功~"}
return JsonResponse(data)
elif request.method == "SYNC":
domain = Domains.objects.filter(deleted_by__id__isnull=True)
if domain:
for item in domain:
api_key = Ali_Parsing(item.api.key, item.api.secret,
item.api.region, item.domain)
if api_key['code'] == 0:
data = json.loads(api_key['data'])
for dom in data['DomainRecords']['Record']:
if "Priority" in dom:
Priority = dom['Priority']
else:
Priority = None
di_ct = {
'RR': dom['RR'],
'Line': dom['Line'],
'Type': dom['Type'],
'Value': dom['Value'],
'RecordId': dom['RecordId'],
'TTL': dom['TTL'],
'domain_id': item.id,
'Priority': Priority
}
Parsing.objects.update_or_create(
RecordId=dom['RecordId'],
defaults=di_ct,
created_by=user)
else:
pass
data = {"code": 0, "msg": "域名解析同步成功~"}
else:
data = {"code": 1, "msg": "域名查找失败~"}
return JsonResponse(data)
def api_edit(request):
request_data = QueryDict(request.body)
did = request_data.get("id", None)
user = user_get(request)
if request.method == "GET":
did = request.GET.get('id')
if did:
data = Api.objects.get(id=did)
else:
data = ""
return render(request, "domains/api_edit.html", {"data": data})
elif request.method == "POST":
data = {
"name": request_data.get("name"),
"cloud": request_data.get("cloud"),
"region": request_data.get("region"),
"key": request_data.get("key"),
"secret": request_data.get("secret"),
"desc": request_data.get("desc"),
}
api_key = Ali_Domain(data["key"], data["secret"], data["region"])
if api_key['code'] == 0:
if did:
Api.objects.filter(id=did).update(**data)
data = {"code": 0, "msg": "API修改成功~"}
else:
Api.objects.create(created_by=user, **data)
data = {"code": 0, "msg": "API添加成功~"}
else:
data = {"code": 0, "msg": "API接口验证失败~"}
return JsonResponse(data)
elif request.method == "DELETE":
Api.objects.filter(id__in=did.split(',')).update(
deleted_at=human_datetime(), deleted_by=user)
data = {"code": 0, "msg": "API删除成功~"}
return JsonResponse(data)
elif request.method == "PUT":
if did:
Api_obj = Api.objects.filter(id__in=did)
else:
Api_obj = Api.objects.all()
if Api_obj.count() < 0:
data = {"code": 1, "msg": f"请添加API接口"}
else:
li_st = []
cg, sb = 0, 0
for item in Api_obj:
data = Ali_Domain(item.key, item.secret, item.region)
if data['code'] == 0:
data = json.loads(data['data'])
for i in data['Domains']['Domain']:
di_ct = {
'api_id': item.id,
'domain': i['DomainName'],
'dns1': i['DnsServers']['DnsServer'][0],
'dns2': i['DnsServers']['DnsServer'][1]
}
Domains.objects.update_or_create(
domain=i['DomainName'],
defaults=di_ct,
created_by=user)
cg += 1
else:
li_st.append(item.name)
sb += 1
if sb > 1:
data = {
"code":
1,
"msg":
f"同步异常，总:{Api_obj.count()},成功:{cg},失败:{sb},失败名称{str(li_st)}"
}
else:
data = {
"code": 0,
"msg": f"同步成功，总:{Api_obj.count()},成功:{cg},失败:{sb}"
}
return JsonResponse(data)
