def post(self, request):
form, error = JsonParser(
Argument('username', help='请输入登录名'),
Argument('password', help='请输入密码'),
).parse(request.body)
if error is None:
if User.objects.filter(username=form.username).exists():
return json_response(error=f'已存在登录名为【{form.username}】的用户')
form.password_hash = User.make_password(form.pop('password'))
# form.created_by = request.user
User.objects.create(**form)
return json_response(error=error)
def delete(self, request):
form, error = JsonParser(Argument('id', type=int,
help='请指定操作对象')).parse(request.GET)
if error is None:
user = User.objects.filter(pk=form.id).first()
if user:
if user.type == 'ldap':
return json_response(error='ldap账户无法删除，请使用禁用功能来禁止该账户访问系统')
user.role_id = None
user.deleted_at = human_datetime()
user.deleted_by = request.user
user.save()
return json_response(error=error)
def get_network_query_crontab_task(request):
"""获取网络探测所有定时任务"""
data = dict()
result = dict()
parameter = request.GET.get("network").replace("$", "/")
if parameter == "all":
all_networks = NetworkQueryList.objects.all()
for network in all_networks:
if network.auto_enable:
network_scan_info = "{0}&{1}&{2}".format(
network.network, network.tcp_query_ports,
network.udp_query_ports)
result[network_scan_info] = network.crontab_task
else:
try:
network = NetworkQueryList.objects.get(network=parameter)
if network and network.auto_enable:
network_scan_info = "{0}&{1}&{2}".format(
network.network, network.tcp_query_ports,
network.udp_query_ports)
result[network_scan_info] = network.crontab_task
except Exception as e:
logging.error(e)
data["status"] = "success"
data['result'] = result
return json_response(data)
def add_device_query_to_cache(request):
"""将设备探测信息加入到redis缓存队列"""
if request.method == "POST":
data = dict()
post_data = json.loads(str(request.body, encoding='utf-8'))
start_ids = post_data["ids"]
# conn_redis = get_redis_connection()
for id in start_ids:
device_info = QueryDevice.objects.get(id=id)
device_ip = device_info.snmp_host
device_snmp_port = device_info.snmp_port
device_snmp_group = device_info.snmp_group
# todo 将任务添加到redis缓存
r.rpush(
conf_data['DEVICE_QUERY_QUEUE'],
"{0} {1} {2}".format(device_ip, device_snmp_port,
device_snmp_group))
logging.info("{0} {1} {2} 加入redis缓存队列".format(
device_ip, device_snmp_port, device_snmp_group))
# 设置探测任务的状态为启动中
QueryDevice.objects.filter(snmp_host=device_ip).update(
query_status=1, last_mod_time=datetime.datetime.now())
data["status"] = "success"
return json_response(data)
def add_network_query_to_cache(request):
if request.method == "POST":
data = dict()
post_data = json.loads(str(request.body, encoding='utf-8'))
ids = post_data["ids"]
if (isinstance(ids, int)):
ids = [ids]
for id in ids:
network_scan_info = NetworkQueryList.objects.get(id=id)
network = network_scan_info.network
tcp_query_ports = network_scan_info.tcp_query_ports
udp_query_ports = network_scan_info.udp_query_ports
network_scan_redis_info = "{0}&{1}&{2}".format(
network, tcp_query_ports, udp_query_ports)
logging.info("{0}&{1}&{2}，加入到redis设备探测队列".format(
network, tcp_query_ports, udp_query_ports))
ips = IP(network)
for ip in ips:
ip = str(ip)
r.rpush(
network_scan_redis_info, ip
) # 将网络中的每个IP地址的探测信息也加入redis环境，key值为network_scan_redis_info
r.rpush(conf_data['NETWORK_QUERY_QUEUE'], network_scan_redis_info)
NetworkQueryList.objects.filter(network=network).update(
query_status=4, query_time=datetime.datetime.now())
data["status"] = "success"
return json_response(data)
def get_device_details(request, parameter):
"""获取设备探测的详细信息"""
device_info = QueryDevice.objects.get(snmp_host=parameter)
device_details = SnmpQueryResult.objects.filter(
snmp_host_int=device_info.snmp_host_int)
data = dict()
result = []
for port_info in device_details:
tmp_data = dict()
tmp_data['key'] = port_info.id
tmp_data["port_name"] = port_info.if_name
if_speed = int(int(port_info.if_speed) / 10**6)
tmp_data["port_speed"] = "{0} Mbps".format(str(if_speed))
if "down" in port_info.if_operstatus:
if_operstatus = "down"
elif "up" in port_info.if_operstatus:
if_operstatus = "up"
else:
if_operstatus = 'unknown'
tmp_data["port_status"] = if_operstatus
tmp_data["port_setup"] = port_info.if_ip_setup
tmp_data["port_index"] = port_info.if_index
tmp_data["port_desc"] = port_info.if_descrs
tmp_data["brige_macs"] = port_info.brige_macs
tmp_data["arp_table"] = port_info.arp_infos
result.append(tmp_data)
data['result'] = result
data["status"] = "success"
# print("data:", data)
return json_response(data)
def get_device_query_info(request):
"""获取所有探测设备的信息"""
page_size = request.GET.get("page_size")
current_page = request.GET.get("current_page")
search_ip = request.GET.get("search_ip")
if search_ip:
all_device = QueryDevice.objects.filter(snmp_host__contains=search_ip)
else:
all_device = QueryDevice.objects.all()
data = dict()
result = []
paginator = Paginator(all_device, page_size)
total_device = all_device.count()
device_page = paginator.page(current_page)
for device in device_page:
tmp_data = dict()
tmp_data['key'] = device.id
tmp_data["ip_address"] = device.snmp_host
tmp_data["device_name"] = device.device_hostname
tmp_data["device_company"] = device.device_manufacturer_info
tmp_data["query_status"] = device.get_query_status_display()
tmp_data["snmp_port"] = device.snmp_port
tmp_data["snmp_community"] = device.snmp_group
tmp_data["auto_enable"] = device.auto_enable
tmp_data["crontab_task"] = device.crontab_time
tmp_data["query_time"] = (
device.last_mod_time +
datetime.timedelta(hours=8)).strftime("%Y-%m-%d %H:%M:%S")
result.append(tmp_data)
data['data'] = result
data['total_device'] = total_device
data["status"] = "success"
return json_response(data)
def check_user_password(request):
"""
判断远程登陆用户名和密码是否准确
"""
if request.method == "POST":
try:
data = dict()
post_data = json.loads(str(request.body, encoding='utf-8'))
info = {
"hostname": post_data["hostname"],
"username": post_data["username"],
"password": post_data["password"],
"port": post_data["port"]
}
ssh = SSH(**info)
ssh.get_client()
data["status"] = "success"
data['result'] = info
except paramiko.ssh_exception.NoValidConnectionsError:
data["status"] = "fail"
data["result"] = u"端口未开放或路由不可达，请重试或关闭！"
except paramiko.ssh_exception.AuthenticationException:
data["status"] = "fail"
data["result"] = u"用户名或密码不准确，请重试或关闭！"
except socket.error as err:
data["status"] = "fail"
data["result"] = u"连接超时，请重试或关闭！"
return json_response(data)
def build_network(request):
data = dict()
if request.method == "POST":
post_data = json.loads(str(request.body, encoding='utf-8'))
networks = post_data["networks"].strip()
parent_group_name = post_data["parent_group_name"]
unvalid_network = []
networks = networks.split(" ")
for network in networks:
try:
if not checkNetwork(network):
unvalid_network.append("{0} 非法网络".format(network))
elif Networks.objects.filter(network=network):
unvalid_network.append("{0} 网络已存在".format(network))
elif "/" not in network:
unvalid_network.append("{0} 非法网络".format(network))
except:
unvalid_network.append("{0} 非法网络".format(network))
if len(unvalid_network) == 0:
network_group_info = NetworkGroup.objects.get(
name=parent_group_name)
network_group_networks = json.loads(network_group_info.networks)
for network in networks:
network_group_networks.append(network)
Networks.objects.create(network=network,
ip_total=IP(network).len(),
query_time=datetime.datetime.now())
"""
通过新建线程，给ip_detail_info表中填入数据
"""
insert_query_data(network)
NetworkGroup.objects.filter(name=parent_group_name).update(
networks=json.dumps(network_group_networks))
data["status"] = "success"
else:
data["status"] = "fail"
data["data"] = unvalid_network
if request.method == "DELETE":
post_data = json.loads(str(request.body, encoding='utf-8'))
networks = post_data.get("networks")
for network in networks:
network_group_info = NetworkGroup.objects.get(
networks__icontains='"' + network + '"')
network_group_networks = json.loads(network_group_info.networks)
network_group_networks.remove(network)
NetworkGroup.objects.filter(name=network_group_info.name).update(
networks=json.dumps(network_group_networks))
Networks.objects.filter(network=network).delete()
# 删除网络下IP地址详细信息
IpDetailsInfo.objects.filter(network=network).delete()
# 删除网络探测配置
NetworkQueryList.objects.filter(network=network).delete()
data["status"] = "success"
return json_response(data)
def handle_networks_set(request):
"""处理网络归集请求"""
data = dict()
post_data = json.loads(str(request.body, encoding='utf-8'))
group = post_data.get("group")
networks = post_data.get("networks")
insert_to_networks = []
for network in networks:
insert_to_networks.append(
Networks(network=network,
ip_total=IP(network).len(),
query_time=datetime.datetime.now()))
# 插入设备探测数据到ip_detail_info表，可以开启一个线程单独执行，待测试
insert_query_data(network)
Networks.objects.bulk_create(insert_to_networks)
network_group_info = NetworkGroup.objects.get(name=group)
network_group_networks = json.loads(network_group_info.networks)
network_group_networks.extend(networks)
NetworkGroup.objects.filter(name=group).update(
networks=json.dumps(network_group_networks))
data["status"] = "success"
return json_response(data)
def get_device_query_crontab_task(request, parameter):
"""获取设备探测所有定时任务"""
data = dict()
result = dict()
if parameter == "all":
all_device = QueryDevice.objects.all()
for device in all_device:
if device.auto_enable:
device_info = "{0} {1} {2}".format(device.snmp_host,
device.snmp_port,
device.snmp_group)
result[device_info] = device.crontab_time
else:
try:
device = QueryDevice.objects.get(snmp_host=parameter)
if device and device.auto_enable:
device_info = "{0} {1} {2}".format(device.snmp_host,
device.snmp_port,
device.snmp_group)
result[device_info] = device.crontab_time
except Exception as e:
logging.error(e)
data["status"] = "success"
data['result'] = result
return json_response(data)
def convert_ip_manual(request):
data = dict()
ip_details = json.loads(str(request.body, encoding='utf-8'))
for ip_detail_dict in ip_details:
IpDetailsInfo.objects.filter(ip=ip_detail_dict['ip']).update(
manual_mac=ip_detail_dict['query_mac'], ip_type=1)
data["status"] = "success"
return json_response(data)
def get_all_group_name(request):
"获取所有的分组名称"
all_groups = NetworkGroup.objects.values_list('name', flat=True)
data = dict()
result = list(all_groups)
result.insert(0, "")
data["result"] = result
data["status"] = "success"
return json_response(data)
def get(self, request):
users = []
for u in User.objects.filter(is_supper=False,
deleted_by_id__isnull=True).annotate(
role_name=F('role__name')):
tmp = u.to_dict(excludes=('access_token', 'password_hash'))
tmp['role_name'] = u.role_name
users.append(tmp)
return json_response(users)
def patch_export_networks(request):
post_data = json.loads(str(request.body, encoding='utf-8'))
networks = post_data["networks"]
data = dict()
result = []
if not networks:
networks = Networks.objects.all()
for network in networks:
network_info = dict()
if isinstance(networks, QuerySet):
total_ips = network.ip_total
network = network.network
else:
network_queryset = Networks.objects.get(network=network)
network = network_queryset.network
total_ips = network_queryset.ip_total
network_info['key'] = network
network_info['network'] = network
network_info['total_ips'] = total_ips
group_name_info = NetworkGroup.objects.get(networks__icontains='"' +
network + '"')
group_name_parent_array = json.loads(group_name_info.parent_array)
if group_name_parent_array:
group_name = "/".join(
group_name_parent_array) + "/" + group_name_info.name
else:
group_name = group_name_info.name
network_info['group_name'] = group_name
network_to_device_info = NetworkToDevice.objects.filter(
network=network)
if network_to_device_info:
network_to_device_hostname = json.loads(
network_to_device_info[0].device_hostname)
network_to_device_ip = json.loads(
network_to_device_info[0].device_ip)
network_to_device_interface = json.loads(
network_to_device_info[0].interface)
else:
network_to_device_ip = []
network_to_device_hostname = []
network_to_device_interface = []
network_info['device_ip'] = ','.join(network_to_device_ip)
network_info['device_interface'] = ','.join(
network_to_device_interface)
network_info['device_name'] = ','.join(network_to_device_hostname)
result.append(network_info)
data["result"] = result
data["status"] = "success"
return json_response(data)
def get_console_info(request):
ip = request.GET.get("ip")
console_info = QueryDevice.objects.get(snmp_host=ip)
result = dict()
result["hostname"] = console_info.snmp_host
result["username"] = console_info.ssh_console_username
result["port"] = console_info.ssh_console_port
data = dict()
data["status"] = "success"
return json_response(data)
def patch(self, request):
data = dict()
form, error = JsonParser(
Argument('ip', required=True),
Argument('network', required=True),
Argument('type', required=True),
Argument('mac', required=True),
).parse(request.body, True)
if error is None:
# 校验mac地址
if is_valid_mac(form.mac):
mac = form.mac.upper()
ip_detail_info = IpDetailsInfo.objects.filter(
ip=form.ip).first()
if ip_detail_info:
if ip_detail_info.query_mac and mac != ip_detail_info.query_mac:
IpDetailsInfo.objects.filter(ip=form.ip).update(
ip_type=2,
manual_mac=mac,
)
else:
IpDetailsInfo.objects.filter(ip=form.ip).update(
ip_type=1,
manual_mac=mac,
)
else:
IpDetailsInfo.objects.create(
ip=form.ip,
network=form.network,
manual_mac=mac,
ip_type=1,
)
data["status"] = "success"
else:
data["status"] = "fail"
return json_response(data)
return json_response(error=error)
def get_groups_to_networks(request):
"""
获取分组对应的网络
"""
data = dict()
group = request.GET.get("group")
if not group:
data["status"] = "success"
data["result"] = []
return json_response(data)
group_info = NetworkGroup.objects.get(name=group)
network_group_networks = json.loads(group_info.networks)
# 获取已经存在的设备探测任务网络
network_query_task_info = NetworkQueryList.objects.values_list('network',
flat=True)
networks = list(
set(network_group_networks).difference(
set(network_query_task_info))) # 提出已经存在的设备探测任务网络
data["status"] = "success"
data["result"] = networks
return json_response(data)
def patch(self, request):
form, error = JsonParser(
Argument('id', type=int, help='请指定操作对象'),
Argument('username', required=False),
Argument('password', required=False),
Argument('nickname', required=False),
Argument('role_id', required=False),
Argument('is_active', type=bool, required=False),
).parse(request.body, True)
if error is None:
if form.get('password'):
form.token_expired = 0
form.password_hash = User.make_password(form.pop('password'))
User.objects.filter(pk=form.pop('id')).update(**form)
return json_response(error=error)
def login(request):
form, error = JsonParser(
Argument('username', help='请输入用户名'),
Argument('password', help='请输入密码'),
).parse(request.body)
if error is None:
x_real_ip = request.META.get('REMOTE_ADDR', '')
user = User.objects.filter(username=form.username).first()
if user and not user.is_active:
return json_response(error="账户已被系统禁用")
else:
if user:
if user.verify_password(form.password):
return handle_user_info(user, x_real_ip)
value = cache.get_or_set(form.username, 0, 86400)
if value >= 3:
if user and user.is_active:
user.is_active = False
user.save()
return json_response(error='账户已被系统禁用')
cache.set(form.username, value + 1, 86400)
return json_response(error="用户名或密码错误，连续多次错误账户将会被禁用")
return json_response(error=error)
def get_udp_ports_details(request, parameter):
ip_details = NetworkQueryDetails.objects.filter(ip=parameter)
udp_port_info = json.loads(ip_details[0].udp_port_list)
result = []
for port_info in udp_port_info:
port_info_dict = dict()
port_info = port_info.split(" ")
port_info_dict["key"] = port_info[0]
port_info_dict["ip"] = parameter
port_info_dict["port"] = port_info[0]
port_info_dict["status"] = port_info[1]
port_info_dict["protocol"] = port_info[2]
result.append(port_info_dict)
data = dict()
data['result'] = result
data["status"] = "success"
return json_response(data)
def del_device_query(request):
"""
批量删除设备探测任务
"""
if request.method == "POST":
post_data = json.loads(str(request.body, encoding='utf-8'))
data = dict()
delete_ids = post_data["ids"]
if (isinstance(delete_ids, int)):
delete_ids = [delete_ids]
for id in delete_ids:
device_info = QueryDevice.objects.get(id=id)
device_ip = device_info.snmp_host
device_snmp_port = device_info.snmp_port
device_snmp_group = device_info.snmp_group
device_hostname = device_info.device_hostname
# 删除snmpqueryresult表中探测数据数据
SnmpQueryResult.objects.filter(
snmp_host_int=ipv4_to_num(device_ip)).delete()
# 批量删除探测任务时候，redis缓存以及该设备相关的探测记录也要对应的删除
device_infos = "{0} {1} {2}".format(device_ip, device_snmp_port,
device_snmp_group)
r.lrem(conf_data['DEVICE_QUERY_QUEUE'], device_infos, 0)
# Todo 删除设备探测任务时候，需要将redis哈希表中的定时任务同步删除
r.hdel(conf_data['DEVICE_QUETY_CRONTAB_HASH'], device_infos)
# 删除network_to_device表中的探测数据
del_network_to_device(device_ip)
device_host_detail = "{0}/{1}".format(device_ip, device_hostname)
# 删除设备探测的arp地址表
del_device_query_arp_table(device_host_detail)
# 删除设备探测的mac地址表
del_device_query_mac_table(device_host_detail)
# 删除网络管理中ip地址详细信息中设备探测相关信息
del_ip_detail_info(device_host_detail)
# 删除设备探测任务记录
QueryDevice.objects.filter(id=id).delete()
data["status"] = "success"
return json_response(data)
def get_group_to_infos(request):
"""获取分组对应的信息"""
group = request.GET.get("group")
group_info = NetworkGroup.objects.get(name=group)
parent_array = json.loads(group_info.parent_array)
networks = json.loads(group_info.networks)
parent_group = ''
if parent_array:
parent_group = parent_array[-1]
data = dict()
result = dict()
result['parent_array'] = parent_group
result['networks'] = networks
data["status"] = "success"
data["result"] = result
return json_response(data)
def get_device_port_macs(request, parameter):
"""
获取设备端口对应的所有mac地址（即端口对应的转发表）
"""
port_info = SnmpQueryResult.objects.get(id=parameter)
if_name = port_info.if_name
# macs = port_info.brige_macs.replace("'", '"')
macs = json.loads(port_info.brige_macs)
data = dict()
result = []
for mac in macs:
tmp_data = dict()
tmp_data['key'] = mac
tmp_data["port_name"] = if_name
tmp_data["mac"] = mac
result.append(tmp_data)
data['result'] = result
data["status"] = "success"
return json_response(data)
def exec_network_query_task(request):
if request.method == "POST":
data = dict()
redis_network_info = request.POST.get("network")
redis_network_info_list = redis_network_info.split("&")
network = redis_network_info_list[0]
# 删除网络管理中ip地址详细信息中网络探测相关信息
del_network_ip_detail_info(network)
NetworkQueryDetails.objects.filter(
network=network).delete() # 在执行网络探测前，先删除网络探测的数据
network_scan = NetworkQuery()
logging.info("执行网络探测任务：{0}".format(redis_network_info))
t = threading.Thread(target=network_scan.exec_redis_task,
args=(redis_network_info, ))
t.start()
data["status"] = "success"
return json_response(data)
def process_request(self, request):
if request.path in settings.AUTHENTICATION_EXCLUDES:
return None
if any(x.match(request.path) for x in settings.AUTHENTICATION_EXCLUDES if hasattr(x, 'match')):
return None
# print("request.META:", request.META)
access_token = request.META.get('HTTP_X_TOKEN') or request.GET.get('x-token')
if access_token and len(access_token) == 32:
# x_real_ip = request.META.get('REMOTE_ADDR', '')
user = User.objects.filter(access_token=access_token).first()
if user and user.token_expired >= time.time() and user.is_active:
request.user = user
if request.path != '/notify/':
user.token_expired = time.time() + settings.LOGIN_EXIPRY_TIME
user.save()
return None
response = json_response(error="验证失败，请重新登录")
response.status_code = 401
return response
def del_network_query(request):
"""
批量删除网络探测任务
"""
if request.method == "POST":
post_data = json.loads(str(request.body, encoding='utf-8'))
data = dict()
delete_ids = post_data["ids"]
if (isinstance(delete_ids, int)):
delete_ids = [delete_ids]
for id in delete_ids:
network_info = NetworkQueryList.objects.get(id=id)
network = network_info.network
tcp_query_ports = network_info.tcp_query_ports
udp_query_ports = network_info.udp_query_ports
print(network)
# todo 删除network_query_result表中探测数据数据
NetworkQueryDetails.objects.filter(network=network).delete()
logging.info("删除网络探测任务：{0}".format(network))
# todo 删除网络探测任务时候，需要将redis网络任务队里的定时任务同步删除
network_scan_redis_info = "{0}&{1}&{2}".format(
network, tcp_query_ports, udp_query_ports)
r.lrem(conf_data['NETWORK_QUERY_QUEUE'], network_scan_redis_info,
0)
logging.info(
"redis网络任务队里的定时任务同步删除：{0}".format(network_scan_redis_info))
# todo 删除网络探测任务时候，需要将redis哈希表中的定时任务同步删除
r.hdel(conf_data['NETWORK_QUETY_CRONTAB_HASH'],
network_scan_redis_info)
r.delete(network_scan_redis_info)
logging.info(
"redis哈希表中的定时任务同步删除：{0}".format(network_scan_redis_info))
# 删除网络探测任务列表
NetworkQueryList.objects.filter(id=id).delete()
# 删除网络管理中ip地址详细信息中网络探测相关信息
del_network_ip_detail_info(network)
data["status"] = "success"
return json_response(data)
def handle_user_info(user, x_real_ip):
cache.delete(user.username)
token_isvalid = user.access_token and len(
user.access_token) == 32 and user.token_expired >= time.time()
user.access_token = user.access_token if token_isvalid else uuid.uuid4(
).hex
user.token_expired = time.time() + settings.LOGIN_EXIPRY_TIME
user.last_login = human_datetime()
user.last_ip = x_real_ip
user.save()
return json_response({
'access_token':
user.access_token,
'is_supper':
user.is_supper,
'has_real_ip':
True if x_real_ip else False,
'host_perms': [] if user.is_supper else user.host_perms,
'permissions': [] if user.is_supper else user.page_perms
})
def get_device_to_networks(request):
"""获取可以网络归集的网络，如果网络管理已存在的网络，需要剔除"""
data = dict()
result = dict()
all_groups = NetworkGroup.objects.values_list('name', flat=True)
all_groups = list(all_groups)
networks_network = Networks.objects.values_list('network', flat=True)
networks_network = list(networks_network)
network_to_device_network = NetworkToDevice.objects.values_list('network',
flat=True)
network_to_device_network = list(network_to_device_network)
difference_networks = list(
set(network_to_device_network).difference(set(networks_network)))
result['all_groups'] = all_groups
result['networks'] = difference_networks
data['result'] = result
data["status"] = "success"
return json_response(data)
def get_device_port_arp(request, parameter):
"""
获取设备端口对应的所有arp信息（即mac和ip地址对应关系）
"""
port_info = SnmpQueryResult.objects.get(id=parameter)
if_name = port_info.if_name
# arp_infos = port_info.arp_infos.replace("'", '"')
arp_infos = json.loads(port_info.arp_infos)
data = dict()
result = []
for arp_info in arp_infos:
tmp_data = dict()
arp_info = arp_info.split(" ")
tmp_data['key'] = arp_info[0]
tmp_data["port_name"] = if_name
tmp_data["ip"] = arp_info[0]
tmp_data["mac"] = arp_info[1]
result.append(tmp_data)
data['result'] = result
data["status"] = "success"
return json_response(data)
