def ip_do_search(request):
"""Search cam and arp based on prefixid or ip range"""
querydict = ProcessInput(request.GET).ip()
form = forms.IpTrackerForm(querydict)
tracker = None
form_data = {}
row_count = 0
from_ip = None
to_ip = None
if form.is_valid():
form_data = form.cleaned_data
ip_range = form.cleaned_data['ip_range']
from_ip, to_ip = (ip_range[0], ip_range[-1])
period_filter = form.cleaned_data['period_filter']
active = inactive = False
if period_filter in ['active', 'both']:
active = True
if period_filter in ['inactive', 'both']:
inactive = True
if (to_ip.int() - from_ip.int()) > ADDRESS_LIMIT:
inactive = False
ip_result = get_result(form.cleaned_data['days'], from_ip, to_ip,
form.cleaned_data['netbios'])
ip_range = create_ip_range(inactive, from_ip, to_ip, ip_result)
tracker = create_tracker(active, form.cleaned_data['dns'], inactive,
ip_range, ip_result)
row_count = sum(len(mac_ip_pair) for mac_ip_pair in tracker.values())
# If the form was valid, but we found no results, display error message
display_no_results = False
if form.is_valid() and not row_count:
display_no_results = True
info_dict = {
'form': form,
'form_data': form_data,
'ip_tracker': tracker,
'ip_tracker_count': row_count,
'subnet_start': unicode(from_ip),
'subnet_end': unicode(to_ip),
'display_no_results': display_no_results,
'colspan': find_colspan('ip', form)
}
info_dict.update(IP_DEFAULTS)
return render_to_response('machinetracker/ip_search.html', info_dict,
RequestContext(request))
def ip_do_search(request):
"""Search CAM and ARP based on IP range"""
querydict = ProcessInput(request.GET).ip()
form = forms.IpTrackerForm(querydict)
tracker = None
form_data = {}
row_count = 0
from_ip = None
to_ip = None
if form.is_valid():
form_data = form.cleaned_data
ip_range = form.cleaned_data['ip_range']
from_ip, to_ip = (ip_range[0], ip_range[-1])
period_filter = form.cleaned_data['period_filter']
active = inactive = False
if period_filter in ['active', 'both']:
active = True
if period_filter in ['inactive', 'both']:
inactive = True
if (to_ip.int() - from_ip.int()) > ADDRESS_LIMIT:
inactive = False
ip_result = get_result(
form.cleaned_data['days'], from_ip, to_ip, form.cleaned_data['netbios']
)
ip_range = create_ip_range(inactive, from_ip, to_ip, ip_result)
tracker = create_tracker(
active, form.cleaned_data['dns'], inactive, ip_range, ip_result
)
row_count = sum(len(mac_ip_pair) for mac_ip_pair in tracker.values())
info_dict = {
'form': form,
'form_data': form_data,
'ip_tracker': tracker,
'ip_tracker_count': row_count,
'subnet_start': six.text_type(from_ip),
'subnet_end': six.text_type(to_ip),
'colspan': find_colspan('ip', form),
}
info_dict.update(IP_DEFAULTS)
return render(request, 'machinetracker/ip_search.html', info_dict)
def netbios_do_search(request):
"""Handle a search for a NETBIOS name"""
form = forms.NetbiosTrackerForm(ProcessInput(request.GET).netbios())
info_dict = {
'form': form,
'form_data': None,
'netbios_tracker': None,
'netbios_tracker_count': 0,
}
if form.is_valid():
searchstring = form.cleaned_data['search']
days = form.cleaned_data['days']
dns = form.cleaned_data['dns']
from_time = date.today() - timedelta(days=days)
filters = (
Q(mac__istartswith=searchstring)
| Q(ip__istartswith=searchstring)
| Q(name__icontains=searchstring)
)
result = Netbios.objects.filter(filters, end_time__gt=from_time)
result = result.order_by('name', 'mac', 'start_time')
nbt_count = len(result)
netbios_tracker = track_mac(
('ip', 'mac', 'name', 'server', 'username', 'start_time', 'end_time'),
result,
dns,
)
info_dict.update(
{
'form_data': form.cleaned_data,
'netbios_tracker': netbios_tracker,
'netbios_tracker_count': nbt_count,
'colspan': find_colspan('netbios', form),
}
)
info_dict.update(NBT_DEFAULTS)
return render(request, 'machinetracker/netbios_search.html', info_dict)
def switch_do_search(request):
"""Does a search in cam and arp based on a switch"""
querydict = ProcessInput(request.GET).swp()
form = forms.SwitchTrackerForm(querydict)
info_dict = {
'form': form,
'form_data': None,
'mac_tracker': None,
'mac_tracker_count': 0,
}
if form.is_valid():
switch = form.cleaned_data['switch']
module = form.cleaned_data.get('module')
port_interface = form.cleaned_data.get('port')
days = form.cleaned_data['days']
from_time = date.today() - timedelta(days=days)
criteria = {}
if module:
criteria['module'] = module
# If port is specified, match on ifindex
if port_interface:
try:
cam_with_ifindex = Cam.objects.filter(
Q(sysname__istartswith=switch) |
Q(netbox__sysname__istartswith=switch),
end_time__gt=from_time,
port=port_interface,
**criteria
).values('ifindex')[0]
criteria['ifindex'] = cam_with_ifindex['ifindex']
except IndexError:
criteria['port'] = port_interface
cam_result = Cam.objects.select_related('netbox').filter(
Q(sysname__istartswith=switch) |
Q(netbox__sysname__istartswith=switch),
end_time__gt=from_time,
**criteria
).order_by('sysname', 'module', 'mac', '-start_time')
# Get last topo jobs on netboxes
netboxes_topo = get_last_job_log_from_netboxes(cam_result, 'topo')
# Flag rows overdue as fishy
for row in cam_result:
if row.netbox in netboxes_topo:
job_log = netboxes_topo[row.netbox]
fishy = job_log and job_log.is_overdue()
row.fishy = job_log if fishy else None
swp_count = len(cam_result)
swp_tracker = track_mac(('mac', 'sysname', 'module', 'port'),
cam_result, dns=False)
info_dict.update({
'form_data': form.cleaned_data,
'mac_tracker': swp_tracker,
'mac_tracker_count': swp_count,
})
info_dict.update(SWP_DEFAULTS)
return render(request, 'machinetracker/switch_search.html', info_dict)
def mac_do_search(request):
"""Does a search based on a mac address"""
querydict = ProcessInput(request.GET).mac()
form = forms.MacTrackerForm(querydict)
info_dict = {
'form': form,
'form_data': None,
'mac_tracker': None,
'ip_tracker': None,
'mac_tracker_count': 0,
'ip_tracker_count': 0,
'disable_ip_context': True,
}
if form.is_valid():
_logger.debug("mac_do_search: form is valid")
mac = form.cleaned_data['mac']
days = form.cleaned_data['days']
dns = form.cleaned_data['dns']
from_time = date.today() - timedelta(days=days)
mac_min, mac_max = min_max_mac(mac)
cam_result = Cam.objects.select_related('netbox').filter(
end_time__gt=from_time,
).extra(
where=['mac BETWEEN %s and %s'],
params=[mac_min, mac_max]
).order_by('mac', 'sysname', 'module', 'port', '-start_time')
arp_result = Arp.objects.select_related('netbox').filter(
end_time__gt=from_time,
mac__range=(mac_min, mac_max)
).order_by('mac', 'ip', '-start_time')
if form.cleaned_data['netbios']:
arp_result = arp_result.extra(
select={'netbiosname': get_netbios_query()})
# Get last ip2mac and topo jobs on netboxes
netboxes_ip2mac = get_last_job_log_from_netboxes(arp_result, 'ip2mac')
netboxes_topo = get_last_job_log_from_netboxes(cam_result, 'topo')
# Flag rows overdue as fishy
for row in arp_result:
if row.netbox in netboxes_ip2mac:
job_log = netboxes_ip2mac[row.netbox]
fishy = job_log and job_log.is_overdue()
row.fishy = job_log if fishy else None
for row in cam_result:
if row.netbox in netboxes_topo:
job_log = netboxes_topo[row.netbox]
fishy = job_log and job_log.is_overdue()
row.fishy = job_log if fishy else None
mac_count = len(cam_result)
ip_count = len(arp_result)
_logger.debug("mac_do_search: processed %d cam rows and %d arp rows",
mac_count, ip_count)
mac_tracker = track_mac(('mac', 'sysname', 'module', 'port'),
cam_result, dns=False)
_logger.debug("mac_do_search: track_mac finished")
uplink_tracker = UplinkTracker(mac_min, mac_max)
interface_tracker = InterfaceTracker(mac_min, mac_max)
ip_tracker = track_mac(('ip', 'mac'), arp_result, dns)
info_dict.update({
'form_data': form.cleaned_data,
'mac_tracker': mac_tracker,
'uplink_tracker': uplink_tracker,
'interface_tracker': interface_tracker,
'ip_tracker': ip_tracker,
'mac_tracker_count': mac_count,
'ip_tracker_count': ip_count,
'colspan': find_colspan('ip', form)
})
info_dict.update(MAC_DEFAULTS)
_logger.debug("mac_do_search: rendering")
return render(request, 'machinetracker/mac_search.html', info_dict)
