def search(request):
"""Controller for searching for locations"""
navpath = get_path()
locations = Location.objects.none()
titles = navpath
if "query" in request.GET:
searchform = LocationSearchForm(request.GET, auto_id=False)
if searchform.is_valid():
titles.append(("Search for %s" % request.GET['query'], ))
locations = process_searchform(searchform)
else:
searchform = LocationSearchForm()
return render(
request,
"info/location/base.html",
{
"searchform": searchform,
"locations": locations,
"navpath": navpath,
"title": create_title(titles)
},
)
def poegroup_details(request, netbox_sysname, grpindex):
"""Show detailed view of one IP device power over ethernet group"""
poegroup = get_object_or_404(
POEGroup.objects.select_related(),
netbox__sysname=netbox_sysname,
index=grpindex,
)
navpath = NAVPATH + [
(
netbox_sysname,
reverse('ipdevinfo-details-by-name',
kwargs={'name': netbox_sysname}),
),
('PoE Details for ' + poegroup.name, ),
]
return render(
request,
'ipdevinfo/poegroup-details.html',
{
'poegroup': poegroup,
'navpath': navpath,
'heading': navpath[-1][0],
'title': create_title(navpath),
},
)
def index(request):
"""Renders the default view for the netbox group page
:param request:
:type request: django.http.HttpRequest
"""
navpath = get_netboxgroup_path()
groups = NetboxGroup.objects.none()
if request.method == 'GET' and 'query' in request.GET:
form = NetboxGroupForm(request.GET)
if form.is_valid():
query = request.GET['query']
id_filter = Q(pk__icontains=query)
netbox_filter = Q(netbox__sysname__icontains=query)
groups = NetboxGroup.objects.filter(
id_filter | netbox_filter).distinct().order_by('id')
else:
form = NetboxGroupForm()
groups = NetboxGroup.objects.all()
return render(request, 'info/netboxgroup/list_groups.html',
{'netboxgroups': groups,
'searchform': form,
'navpath': navpath,
'title': create_title(navpath)})
def service_list(request, handler=None):
"""List services with given handler or any handler"""
page = request.GET.get('page', '1')
services = Service.objects.select_related('netbox').order_by(
'netbox__sysname', 'handler')
if handler:
services = services.filter(handler=handler)
handler_list = Service.objects.values('handler').distinct()
navpath = NAVPATH + [('Service List', )]
# Pass on to generic view
return SubListView.as_view(
queryset=services,
paginate_by=100,
template_name='ipdevinfo/service-list.html',
allow_empty=True,
extra_context={
'show_ipdev_info': True,
'handler_list': handler_list,
'handler': handler,
'title': create_title(navpath),
'navpath': navpath,
'heading': navpath[-1][0],
'services': services,
'page': page,
'template_object_name': 'service'
},
)(request)
def add_threshold(request, metric=None):
"""Controller for threshold search"""
if request.method == 'POST':
form = ThresholdForm(request.POST)
metric = request.POST.get('target')
if form.is_valid():
handle_threshold_form(form, request)
return redirect('threshold-index')
else:
if metric:
form = ThresholdForm(initial={'target': metric})
else:
form = ThresholdForm()
heading = 'Add threshold rule'
navpath = get_path() + [(heading, )]
title = create_title(navpath)
context = {
'heading': heading,
'form': form,
'metric': metric,
'title': title,
'navpath': navpath,
'id': None,
}
return render(request, 'threshold/set_threshold.html', context)
def upload_image(request, roomid):
"""Controller for uploading an image"""
room = get_object_or_404(Room, pk=roomid)
navpath = get_path() + [
(room.id, reverse('room-info', kwargs={'roomid': room.id})),
('Edit images',)
]
account = get_account(request)
if request.method == 'POST':
_logger.debug('Uploading images')
images = request.FILES.getlist('images')
for image in images:
try:
handle_image(image, room, uploader=account)
messages.success(
request, 'Image «%s» uploaded' % image.name)
except IOError as e:
_logger.error(e)
messages.error(request, 'Image «%s» not saved - '
'perhaps unsupported type' % image.name)
return redirect("room-info-upload", roomid=room.id)
return render_to_response("info/room/upload.html",
{"room": room, "navpath": navpath,
"title": create_title(navpath)},
context_instance=RequestContext(request))
def index(request):
"""Main controller"""
searchproviders = []
navpath = [('Home', '/'), ('Search', reverse('info-search'))]
titles = navpath
if "query" in request.GET:
form = SearchForm(request.GET, auto_id=False)
if form.is_valid():
titles.append(('Search for "%s"' % request.GET["query"], ))
searchproviders = process_form(form)
if has_only_one_result(searchproviders):
return HttpResponseRedirect(searchproviders[0].results[0].href)
else:
form = SearchForm()
return render_to_response("info/base.html", {
"form": form,
"searchproviders": searchproviders,
"navpath": navpath,
"title": create_title(titles)
},
context_instance=RequestContext(request))
def service_list(request, handler=None):
"""List services with given handler or any handler"""
page = request.GET.get('page', '1')
services = Service.objects.select_related(depth=1).order_by(
'netbox__sysname', 'handler')
if handler:
services = services.filter(handler=handler)
handler_list = Service.objects.values('handler').distinct()
navpath = NAVPATH + [('Service List', )]
# Pass on to generic view
return object_list(request,
services,
paginate_by=100,
page=page,
template_name='ipdevinfo/service-list.html',
extra_context={
'show_ipdev_info': True,
'handler_list': handler_list,
'handler': handler,
'title': create_title(navpath),
'navpath': navpath,
'heading': navpath[-1][0]
},
allow_empty=True,
context_processors=[search_form_processor],
template_object_name='service')
def search(request):
"""Controller for searching for rooms"""
navpath = get_path()
rooms = Room.objects.none()
titles = navpath
if "query" in request.GET:
searchform = RoomSearchForm(request.GET, auto_id=False)
if searchform.is_valid():
titles.append(("Search for %s" % request.GET['query'],))
rooms = process_searchform(searchform)
for room in rooms:
room.netboxes = filter_netboxes(room)
else:
searchform = RoomSearchForm()
return render(
request,
"info/room/base.html",
{
"searchform": searchform,
"rooms": rooms,
"navpath": navpath,
"title": create_title(titles)
}
)
def search(request):
"""Search for an IP device"""
titles = NAVPATH
errors = []
netboxes = None
query = None
if 'query' in request.GET:
search_form = SearchForm(request.GET)
if search_form.is_valid():
# Preprocess query string
query = search_form.cleaned_data['query'].strip().lower()
titles = titles + [("Search for %s" % query,)]
netboxes = find_netboxes(errors, query)
# If only one hit, redirect to details view
if netboxes and len(netboxes) == 1:
return ipdev_details(request, name=netboxes[0].sysname)
else:
search_form = SearchForm()
return render_to_response('ipdevinfo/search.html',
{'errors': errors, 'netboxes': netboxes,
'navpath': NAVPATH, 'query': query,
'title': create_title(titles),
'search_form': search_form},
context_instance=RequestContext(
request, processors=[search_form_processor]))
def service_matrix(request):
"""Show service status in a matrix with one IP Device per row and one
service handler per column"""
handler_list = [
h['handler'] for h in Service.objects.values('handler').distinct()
]
matrix_dict = {}
for service in Service.objects.select_related(depth=1):
if service.netbox.id not in matrix_dict:
matrix_dict[service.netbox.id] = {
'sysname': service.netbox.sysname,
'netbox': service.netbox,
'services': [None for _ in handler_list],
}
index = handler_list.index(service.handler)
matrix_dict[service.netbox.id]['services'][index] = service
matrix = matrix_dict.values()
navpath = NAVPATH + [('Service Matrix', )]
return render_to_response('ipdevinfo/service-matrix.html', {
'handler_list': handler_list,
'matrix': matrix,
'title': create_title(navpath),
'navpath': navpath,
'heading': navpath[-1][0]
},
context_instance=RequestContext(
request, processors=[search_form_processor]))
def service_list(request, handler=None):
"""List services with given handler or any handler"""
page = request.GET.get('page', '1')
services = Service.objects.select_related(depth=1).order_by(
'netbox__sysname', 'handler')
if handler:
services = services.filter(handler=handler)
handler_list = Service.objects.values('handler').distinct()
navpath = NAVPATH + [('Service List',)]
# Pass on to generic view
return object_list(
request,
services,
paginate_by=100,
page=page,
template_name='ipdevinfo/service-list.html',
extra_context={
'show_ipdev_info': True,
'handler_list': handler_list,
'handler': handler,
'title': create_title(navpath),
'navpath': navpath,
'heading': navpath[-1][0]
},
allow_empty=True,
context_processors=[search_form_processor],
template_object_name='service')
def vlan_details(request, vlanid):
"""Render details for a vlan"""
vlan = get_object_or_404(Vlan.objects.select_related(depth=1), pk=vlanid)
prefixes = sorted(vlan.prefix_set.all(),
key=methodcaller('get_prefix_size'))
has_v6 = False
has_v4 = False
for prefix in prefixes:
version = IP(prefix.net_address).version()
if version == 6:
has_v6 = True
elif version == 4:
has_v4 = True
navpath = get_path([(str(vlan), '')])
return render_to_response('info/vlan/vlandetails.html',
{'vlan': vlan,
'prefixes': prefixes,
'gwportprefixes': find_gwportprefixes(vlan),
'navpath': navpath,
'has_v4': has_v4,
'has_v6': has_v6,
'title': create_title(navpath)},
context_instance=RequestContext(request))
def search(request):
"""Search for an IP device"""
titles = NAVPATH
errors = []
netboxes = None
query = None
if 'query' in request.GET:
search_form = SearchForm(request.GET)
if search_form.is_valid():
# Preprocess query string
query = search_form.cleaned_data['query'].strip().lower()
titles = titles + [("Search for %s" % query, )]
netboxes = find_netboxes(errors, query)
# If only one hit, redirect to details view
if netboxes and len(netboxes) == 1:
return ipdev_details(request, name=netboxes[0].sysname)
else:
search_form = SearchForm()
return render_to_response('ipdevinfo/search.html', {
'errors': errors,
'netboxes': netboxes,
'navpath': NAVPATH,
'query': query,
'title': create_title(titles),
'search_form': search_form
},
context_instance=RequestContext(
request, processors=[search_form_processor]))
def group_edit(request, groupid):
"""Renders the view for editing device groups
:param request:
:type request: django.http.HttpRequest
"""
group = get_object_or_404(NetboxGroup, pk=groupid)
navpath = get_netboxgroup_path([(group.pk, ), ('edit', )])
if request.method == 'POST':
return handle_edit_request(request, group)
netboxes = Netbox.objects.exclude(
pk__in=group.netbox_set.all().values_list('id', flat=True))
return render(
request,
'info/netboxgroup/group_edit.html',
{
'netboxgroup': group,
'netboxes': netboxes,
'navpath': navpath,
'title': create_title(navpath),
},
)
def group_detail(request, groupid):
"""Renders the view for group detail
:param request:
:type request: django.http.HttpRequest
"""
group = get_object_or_404(NetboxGroup, pk=groupid)
netboxes = group.netbox_set.select_related('organization', 'category',
'type')
availabilities = get_netboxes_availability(netboxes,
data_sources=['availability'],
time_frames=['week', 'month'])
navpath = get_netboxgroup_path([(group.pk, )])
return render(
request,
'info/netboxgroup/group_detail.html',
{
'netboxgroup': group,
'netboxes': netboxes,
'availabilities': availabilities,
'navpath': navpath,
'title': create_title(navpath),
},
)
def account_charts(request):
"""Displays the page for account charts"""
context = {}
if 'send' in request.GET:
form = AccountChartsForm(request.GET)
if form.is_valid():
days = form.cleaned_data['days']
tables = []
for chart in form.cleaned_data['charts']:
query = AcctChartsQuery(chart, days)
query.execute()
tables.append(
(query.table_title, query.result))
context['tables'] = tables
else:
form = AccountChartsForm()
navpath = get_navpath(('Account Charts', ))
context.update({
'navpath': navpath,
'title': create_title(navpath),
'form': form,
'acctcharts': True
})
return render_to_response('radius/account_charts.html', context,
context_instance=RequestContext(request))
def account_charts(request):
"""Displays the page for account charts"""
context = {}
if 'send' in request.GET:
form = AccountChartsForm(request.GET)
if form.is_valid():
days = form.cleaned_data['days']
tables = []
for chart in form.cleaned_data['charts']:
query = AcctChartsQuery(chart, days)
query.execute()
tables.append((query.table_title, query.result))
context['tables'] = tables
else:
form = AccountChartsForm()
navpath = get_navpath(('Account Charts', ))
context.update({
'navpath': navpath,
'title': create_title(navpath),
'form': form,
'acctcharts': True
})
return render_to_response('radius/account_charts.html',
context,
context_instance=RequestContext(request))
def service_matrix(request):
"""Show service status in a matrix with one IP Device per row and one
service handler per column"""
handler_list = [h['handler']
for h in Service.objects.values('handler').distinct()]
matrix_dict = {}
for service in Service.objects.select_related(depth=1):
if service.netbox.id not in matrix_dict:
matrix_dict[service.netbox.id] = {
'sysname': service.netbox.sysname,
'netbox': service.netbox,
'services': [None for _ in handler_list],
}
index = handler_list.index(service.handler)
matrix_dict[service.netbox.id]['services'][index] = service
matrix = matrix_dict.values()
navpath = NAVPATH + [('Service Matrix',)]
return render_to_response(
'ipdevinfo/service-matrix.html',
{
'handler_list': handler_list,
'matrix': matrix,
'title': create_title(navpath),
'navpath': navpath,
'heading': navpath[-1][0]
},
context_instance=RequestContext(request,
processors=[search_form_processor]))
def edit_threshold(request, rule_id):
"""Controller for editing threshold rules"""
rule = get_object_or_404(ThresholdRule, pk=rule_id)
if request.method == 'POST':
form = ThresholdForm(request.POST, instance=rule)
metric = request.POST.get('target')
if form.is_valid():
handle_threshold_form(form, request)
return redirect('threshold-index')
else:
form = ThresholdForm(instance=rule)
metric = rule.target
heading = 'Edit threshold rule'
navpath = get_path() + [(heading, )]
title = create_title(navpath)
context = {
'heading': heading,
'form': form,
'metric': metric,
'title': title,
'navpath': navpath,
'id': rule.id,
}
return render(request, 'threshold/set_threshold.html', context)
def vlan_details(request, vlanid):
"""Render details for a vlan"""
vlan = get_object_or_404(Vlan, pk=vlanid)
prefixes = sorted(vlan.prefix_set.all(), key=methodcaller('get_prefix_size'))
has_v6 = False
has_v4 = False
for prefix in prefixes:
version = IP(prefix.net_address).version()
if version == 6:
has_v6 = True
elif version == 4:
has_v4 = True
navpath = get_path([(str(vlan), '')])
return render(
request,
'info/vlan/vlandetails.html',
{
'vlan': vlan,
'prefixes': prefixes,
'gwportprefixes': find_gwportprefixes(vlan),
'navpath': navpath,
'has_v4': has_v4,
'has_v6': has_v6,
'title': create_title(navpath),
},
)
def index(request):
"""Controller for vlan landing page and search"""
vlans = Vlan.objects.none()
navpath = get_path()
if "query" in request.GET:
searchform = VlanSearchForm(request.GET)
if searchform.is_valid():
navpath = get_path([('Search for "%s"' % request.GET['query'],)])
vlans = process_searchform(searchform)
else:
searchform = VlanSearchForm()
_logger.debug(vlans)
return render(
request,
"info/vlan/base.html",
{
'navpath': navpath,
'title': create_title(navpath),
'form': searchform,
'vlans': vlans,
},
)
def index(request):
"""Renders the default view for the netbox group page
:param request:
:type request: django.http.HttpRequest
"""
navpath = get_netboxgroup_path()
groups = NetboxGroup.objects.none()
if request.method == 'GET' and 'query' in request.GET:
form = NetboxGroupForm(request.GET)
if form.is_valid():
query = request.GET['query']
id_filter = Q(pk__icontains=query)
netbox_filter = Q(netbox__sysname__icontains=query)
groups = NetboxGroup.objects.filter(
id_filter | netbox_filter).distinct().order_by('id')
else:
form = NetboxGroupForm()
groups = NetboxGroup.objects.all()
return render(
request, 'info/netboxgroup/list_groups.html', {
'netboxgroups': groups,
'searchform': form,
'navpath': navpath,
'title': create_title(navpath)
})
def get_context():
"""Returns common context"""
navpath = (
('Home', '/'),
('Event details', ''),
)
return {'navpath': navpath, 'title': utils.create_title(navpath)}
def create_context(path, context):
"""Create a dictionary for use in context based on path"""
navpath = NAVPATH + [(path,)]
path_context = {
'navpath': navpath,
'title': create_title(navpath)
}
return dict(path_context.items() + context.items())
def render_page(request, extra_context):
"""Render the page with a given context"""
navpath = [('Home', '/'), ('Unrecognized Neighbors', )]
context = {
'navpath': navpath,
'title': create_title(navpath),
}
context.update(extra_context)
return render(request, 'neighbors/base.html', context)
def create_context(path, context):
"""Create a dictionary for use in context based on path"""
navpath = NAVPATH + [(path,)]
path_context = {
'navpath': navpath,
'title': create_title(navpath)
}
path_context.update(context)
return path_context
def log_search(request):
"""Displays the page for doing a radius log search"""
context = {}
if 'send' in request.GET:
form = ErrorLogSearchForm(request.GET)
if form.is_valid():
data = form.cleaned_data
searchstring = data.get('query')[1]
searchtype = data.get('query')[0]
hours = timestamp = slack = ''
time = data.get('time')
timemode = time[0] if time and len(time) == 2 else ''
if timemode == 'hours':
hours = time[0]
elif timemode == 'timestamp':
timestamp, slack = split_time(time[1])
query = LogSearchQuery(
searchstring,
searchtype,
data.get('log_entry_type'),
timemode,
timestamp,
slack,
hours,
'time',
'DESC'
)
query.execute()
field_desc = [
LOG_FIELDDESCRIPTIONS[field]
for field in LOG_SEARCHRESULTFIELDS
]
context.update({
'field_desc': field_desc,
'result': query.result
})
else:
context['errors'] = form.errors
else:
form = ErrorLogSearchForm()
navpath = get_navpath(('Error Log',))
context.update({
'navpath': navpath,
'title': create_title(navpath),
'form': form,
'logsearch': True
})
return render_to_response('radius/error_log.html', context,
context_instance=RequestContext(request))
def get_base_context(additional_paths=None, form=None):
"""Returns a base context for portadmin
:type additional_paths: list of tuple
"""
navpath = [('Home', '/'), ('PortAdmin', reverse('portadmin-index'))]
if additional_paths:
navpath += additional_paths
form = form if form else SearchForm()
return {'navpath': navpath, 'title': create_title(navpath), 'form': form}
def account_search(request):
"""Displays the page for doing an account log search"""
context = {}
if 'send' in request.GET:
form = AccountLogSearchForm(request.GET)
if form.is_valid():
data = form.cleaned_data
days = timestamp = slack = ''
time = data.get('time')
timemode = time[0] if time and len(time) == 2 else ''
if timemode == 'days':
days = time[1]
elif timemode == 'timestamp':
timestamp, slack = split_time(time[1])
dns_lookup = data.get('dns_lookup')
query = AcctSearchQuery(
data.get('query')[1],
data.get('query')[0],
data.get('port_type'),
timemode,
timestamp,
slack,
days,
'userdns' in dns_lookup,
'nasdns' in dns_lookup,
'acctstarttime',
'DESC'
)
query.execute()
(total_time, total_sent, total_received) = query.make_stats()
context.update({
'result': query.result,
'total_time': total_time,
'total_sent': total_sent,
'total_received': total_received,
})
else:
context['errors'] = form.errors
else:
form = AccountLogSearchForm()
navpath = get_navpath(('Account Log', ))
context.update({
'title': create_title(navpath),
'navpath': navpath,
'form': form,
'acctsearch': True
})
return render_to_response('radius/account_log.html', context,
context_instance=RequestContext(request))
def render_index(request):
"""Controller for WatchDog index"""
navpath = [('Home', '/'), ('WatchDog', )]
context = {
'navpath': navpath,
'title': create_title(navpath),
'tests': get_statuses()
}
return render(request, 'watchdog/base.html', context)
def render_index(request):
"""Controller for WatchDog index"""
navpath = [('Home', '/'), ('WatchDog', )]
context = {
'navpath': navpath,
'title': create_title(navpath),
'tests': get_statuses()
}
return render(request, 'watchdog/base.html', context)
def render_index(request):
"""Controller for WatchDog index"""
navpath = [("Home", "/"), ("WatchDog", )]
context = {
"navpath": navpath,
"title": create_title(navpath),
"tests": get_statuses(),
}
return render(request, "watchdog/base.html", context)
def get_context(prefix=None):
"""Returns a context for a page with a possible prefix"""
navpath = [('Home', '/'), ('Search', reverse('info-search')),
('Prefix', reverse('prefix-index'))]
if prefix:
navpath.append((prefix.net_address, ))
return {
'prefix': prefix,
'navpath': navpath,
'title': utils.create_title(navpath)
}
def get_context_data(self, **kwargs):
verbs = list(LogEntry.objects.order_by().values_list(
'verb', flat=True).distinct())
verbs.sort()
navpath = (get_navpath_root(), ('Audit Log', ))
context = {
'auditlog_verbs': verbs,
'navpath': navpath,
'title': create_title(navpath),
}
context.update(**kwargs)
return super(AuditlogOverview, self).get_context_data(**context)
def locationinfo(request, locationid):
"""Controller for displaying locationinfo"""
location = get_object_or_404(Location, id=locationid)
navpath = get_path() + [(location.id, )]
location.sorted_data = sorted(location.data.items())
return render(
request, "info/location/locationinfo.html", {
"location": location,
"navpath": navpath,
"images": location.image_set.all(),
"title": create_title(navpath)
})
def roominfo(request, roomid):
"""Controller for displaying roominfo"""
room = get_object_or_404(Room, id=roomid)
images = room.image_set.all()
navpath = get_path() + [(room.id,)]
room.sorted_data = sorted(room.data.items())
room.meta_data = get_room_meta(room)
return render_to_response("info/room/roominfo.html",
{"room": room,
"navpath": navpath,
"title": create_title(navpath),
"images": images},
context_instance=RequestContext(request))
def roominfo(request, roomid):
"""Controller for displaying roominfo"""
room = get_object_or_404(Room, id=roomid)
images = room.image_set.all()
navpath = get_path() + [(room.id,)]
room.sorted_data = sorted(room.data.items())
return render_to_response("info/room/roominfo.html",
{"room": room,
"navpath": navpath,
"title": create_title(navpath),
"images": images},
context_instance=RequestContext(request))
def group_detail(request, groupid):
"""Renders the view for group detail
:param request:
:type request: django.http.HttpRequest
"""
group = get_object_or_404(NetboxGroup, pk=groupid)
navpath = get_netboxgroup_path([(group.pk,)])
return render(request, 'info/netboxgroup/group_detail.html',
{'netboxgroup': group, 'navpath': navpath,
'title': create_title(navpath)})
def upload_image(request, roomid):
"""Controller for uploading an image"""
room = get_object_or_404(Room, pk=roomid)
navpath = get_path() + [
(room.id, reverse('room-info', kwargs={'roomid': room.id})),
('Edit images', )
]
account = get_account(request)
if request.method == 'POST':
_logger.debug('Uploading image')
uploadform = UploadForm(request.POST, request.FILES)
if uploadform.is_valid():
image = request.FILES['roomimage'].read()
original_name = request.FILES['roomimage'].name
imagename = "%s%s" % (create_hash(
image, True), get_extension(original_name))
imagedirectory = create_hash(room.id)
imagedirectorypath = join(ROOMIMAGEPATH, imagedirectory)
title = request.POST.get('title') or original_name
create_image_directory(imagedirectorypath)
save_image(image, join(imagedirectorypath, imagename))
save_thumbnail(imagename, imagedirectorypath,
join(imagedirectorypath, 'thumbs'))
Image(title=title,
path=imagedirectory,
name=imagename,
room=room,
priority=get_next_priority(room),
uploader=account).save()
messages.success(request, 'Image uploaded')
return redirect("room-info-upload", roomid=room.id)
else:
_logger.debug('Showing upload form')
uploadform = UploadForm()
return render_to_response("info/room/upload.html", {
"room": room,
"navpath": navpath,
"title": create_title(navpath),
'uploadform': uploadform
},
context_instance=RequestContext(request))
def get_base_context(additional_paths=None, form=None):
"""Returns a base context for portadmin
:type additional_paths: list of tuple
"""
navpath = [('Home', '/'), ('PortAdmin', reverse('portadmin-index'))]
if additional_paths:
navpath += additional_paths
form = form if form else SearchForm()
return {
'header': {'name': 'PortAdmin',
'description': 'Configure interfaces on ip devices'},
'navpath': navpath,
'title': create_title(navpath),
'form': form
}
def upload_image(request, roomid):
"""Controller for uploading an image"""
room = get_object_or_404(Room, pk=roomid)
navpath = get_path() + [
(room.id, reverse('room-info', kwargs={'roomid': room.id})),
('Edit images',)
]
account = get_account(request)
if request.method == 'POST':
_logger.debug('Uploading image')
uploadform = UploadForm(request.POST, request.FILES)
if uploadform.is_valid():
image = request.FILES['roomimage'].read()
original_name = request.FILES['roomimage'].name
imagename = "%s%s" % (create_hash(image, True),
get_extension(original_name))
imagedirectory = create_hash(room.id)
imagedirectorypath = join(ROOMIMAGEPATH, imagedirectory)
title = request.POST.get('title') or original_name
create_image_directory(imagedirectorypath)
save_image(image, join(imagedirectorypath, imagename))
save_thumbnail(imagename, imagedirectorypath,
join(imagedirectorypath, 'thumbs'))
Image(title=title, path=imagedirectory, name=imagename, room=room,
priority=get_next_priority(room),
uploader=account).save()
messages.success(request, 'Image uploaded')
return redirect("room-info-upload", roomid=room.id)
else:
_logger.debug('Showing upload form')
uploadform = UploadForm()
return render_to_response("info/room/upload.html",
{"room": room, "navpath": navpath,
"title": create_title(navpath),
'uploadform': uploadform},
context_instance=RequestContext(request))
def group_edit(request, groupid):
"""Renders the view for editing device groups
:param request:
:type request: django.http.HttpRequest
"""
group = get_object_or_404(NetboxGroup, pk=groupid)
navpath = get_netboxgroup_path([(group.pk,), ('edit',)])
if request.method == 'POST':
return handle_edit_request(request, group)
netboxes = Netbox.objects.exclude(
pk__in=group.netbox_set.all().values_list('id', flat=True))
return render(request, 'info/netboxgroup/group_edit.html',
{'netboxgroup': group, 'netboxes': netboxes,
'navpath': navpath, 'title': create_title(navpath)})
def log_detail(request, accountid, template):
"""Displays log details for accountid with the given template"""
query = LogDetailQuery(accountid)
query.execute()
result = query.result[0]
field_desc = [
LOG_FIELDDESCRIPTIONS[field]
for field in LOG_DETAILFIELDS]
fields = zip(field_desc, result)
navpath = get_navpath(('Log Detail', ))
context = {
'reverse': reverse('radius-log_detail', args=(accountid, )),
'title': create_title(navpath),
'navpath': navpath,
'fields': fields,
}
return render_to_response(template, context,
context_instance=RequestContext(request))
def index(request):
"""Controller for vlan landing page and search"""
vlans = Vlan.objects.none()
navpath = get_path()
if "query" in request.GET:
searchform = SearchForm(request.GET)
if searchform.is_valid():
navpath = get_path([('Search for "%s"' % request.GET['query'], )])
vlans = process_searchform(searchform)
else:
searchform = SearchForm()
LOGGER.debug(vlans)
return render_to_response("info/vlan/base.html",
{'navpath': navpath,
'title': create_title(navpath),
'form': searchform,
'vlans': vlans},
context_instance=RequestContext(request))
def account_detail(request, accountid, template):
"""Finds account details for a specific accountid"""
query = AcctDetailQuery(accountid)
query.execute()
result = query.result[0]
field_desc = [
ACCT_DBFIELDSDESCRIPTIONS[field]
for field in ACCT_DETAILSFIELDS]
fields = zip(field_desc, result)
navpath = get_navpath(('Account Detail',))
context = {
'reverse': reverse('radius-account_detail', args=(accountid, )),
'title': create_title(navpath),
'navpath': navpath,
'fields': fields,
'result': query.result
}
return render_to_response(template, context,
context_instance=RequestContext(request))
def search(request):
"""Controller for searching for rooms"""
navpath = get_path()
rooms = Room.objects.none()
titles = navpath
if "query" in request.GET:
searchform = SearchForm(request.GET, auto_id=False)
if searchform.is_valid():
titles.append(("Search for %s" % request.GET['query'],))
rooms = process_searchform(searchform)
for room in rooms:
room.netboxes = filter_netboxes(room)
else:
searchform = SearchForm()
return render_to_response("info/room/base.html",
{"searchform": searchform,
"rooms": rooms,
"navpath": navpath,
"title": create_title(titles)},
context_instance=RequestContext(request))
def index(request):
"""Main controller"""
searchproviders = []
navpath = [('Home', '/'), ('Search', reverse('info-search'))]
titles = navpath
if "query" in request.GET:
form = SearchForm(request.GET, auto_id=False)
if form.is_valid():
titles.append(('Search for "%s"' % request.GET["query"],))
searchproviders = process_form(form)
if has_only_one_result(searchproviders):
return HttpResponseRedirect(searchproviders[0].results[0].href)
else:
form = SearchForm()
return render_to_response("info/base.html",
{"form": form,
"searchproviders": searchproviders,
"navpath": navpath,
"title": create_title(titles)},
context_instance=RequestContext(request))
def ipdev_details(request, name=None, addr=None, netbox_id=None):
"""Show detailed view of one IP device"""
if netbox_id:
netbox = get_object_or_404(Netbox, id=netbox_id)
return HttpResponseRedirect(netbox.get_absolute_url())
def get_netbox(name=None, addr=None):
"""Lookup IP device in NAV by either hostname or IP address"""
# Prefetch related objects as to reduce number of database queries
netboxes = Netbox.objects.select_related(depth=2)
netbox = None
if name:
try:
netbox = netboxes.get(Q(sysname=name) | Q(ip=name))
except Netbox.DoesNotExist:
pass
elif addr:
try:
netbox = netboxes.get(ip=addr)
except Netbox.DoesNotExist:
pass
if not netbox:
host_information = get_host_info(name or addr)
for address in host_information['addresses']:
if 'name' in address:
try:
netbox = netboxes.get(sysname=address['name'])
break # Exit loop at first match
except Netbox.DoesNotExist:
pass
return netbox
def get_recent_alerts(netbox, days_back=7, max_num_alerts=15):
"""Returns the most recents alerts related to a netbox"""
# Limit to alerts which where closed in the last days or which are
# still open
lowest_end_time = dt.datetime.now() - dt.timedelta(days=days_back)
filter_stateful = Q(end_time__gt=lowest_end_time)
filter_stateless = (Q(end_time__isnull=True)
& Q(start_time__gt=lowest_end_time))
queryset = netbox.alerthistory_set.filter(
filter_stateful | filter_stateless
).order_by('-start_time')
count = queryset.count()
raw_alerts = queryset[:max_num_alerts]
alerts = []
has_unresolved_alerts = False
for alert in raw_alerts:
if alert.source.name == 'serviceping':
try:
alert_type = Service.objects.get(id=alert.subid).handler
except Service.DoesNotExist:
alert_type = '%s (%s)' % (alert.event_type, alert.subid)
else:
alert_type = '%s' % alert.event_type
try:
message = alert.messages.filter(type='sms')[0].message
except IndexError:
message = None
if not has_unresolved_alerts and alert.is_open():
has_unresolved_alerts = True
alerts.append({
'alert': alert,
'type': alert_type,
'message': message,
})
return {
'days_back': days_back,
'alerts': alerts,
'count': count,
'is_more_alerts': count > max_num_alerts,
'has_unresolved_alerts': has_unresolved_alerts
}
def get_prefix_info(addr):
"""Return prefix based on address"""
ipaddr = is_valid_ip(addr)
if ipaddr:
prefixes = Prefix.objects.select_related().extra(
select={"mask_size": "masklen(netaddr)"},
where=["%s << netaddr AND nettype <> 'scope'"],
order_by=["-mask_size"], params=[ipaddr])[0:1]
if prefixes:
return prefixes[0]
return None
def get_arp_info(addr):
"""Return arp based on address"""
ipaddr = is_valid_ip(addr)
if ipaddr:
arp_info = Arp.objects.extra(
where=["ip = %s"],
params=[ipaddr]).order_by('-end_time', '-start_time')[0:1]
if arp_info:
return arp_info[0]
return None
def get_cam_info(mac):
"""Return cam objects based on mac address"""
cam_info = Cam.objects.filter(mac=mac).order_by('-end_time',
'-start_time')[0:1]
return cam_info[0] if cam_info else None
# Get data needed by the template
addr = is_valid_ip(addr)
host_info = None
netbox = get_netbox(name=name, addr=addr)
# Assign default values to variables
no_netbox = {
'prefix': None,
'arp': None,
'cam': None,
'dt_max': dt.datetime.max,
'days_since_active': 7,
}
alert_info = None
job_descriptions = None
system_metrics = netbox_availability = []
graphite_error = False
# If addr or host not a netbox it is not monitored by NAV
if netbox is None:
host_info = get_host_info(name or addr)
if not addr and len(host_info['addresses']) > 0:
# Picks the first address in array if addr not specified
addr = host_info['addresses'][0]['addr']
no_netbox['prefix'] = get_prefix_info(addr)
netboxgroups = None
navpath = NAVPATH + [(host_info['host'], '')]
if no_netbox['prefix']:
no_netbox['arp'] = get_arp_info(addr)
if no_netbox['arp']:
no_netbox['cam'] = get_cam_info(no_netbox['arp'].mac)
if no_netbox['arp'].end_time < dt.datetime.max:
no_netbox['days_since_active'] = \
(dt.datetime.now() - no_netbox['arp'].end_time).days
else:
alert_info = get_recent_alerts(netbox)
netboxgroups = netbox.netboxcategory_set.all()
navpath = NAVPATH + [(netbox.sysname, '')]
job_descriptions = get_job_descriptions()
try:
system_metrics = netbox.get_system_metrics()
except GraphiteUnreachableError:
graphite_error = True
try:
netbox_availability = netbox.get_availability()
except GraphiteUnreachableError:
graphite_error = True
return render_to_response(
'ipdevinfo/ipdev-details.html',
{
'host_info': host_info,
'netbox': netbox,
'interfaces': (netbox.interface_set.order_by('ifindex')
if netbox else None),
'counter_types': ('Octets', 'UcastPkts', 'Errors', 'Discards'),
'heading': navpath[-1][0],
'alert_info': alert_info,
'no_netbox': no_netbox,
'netboxgroups': netboxgroups,
'job_descriptions': job_descriptions,
'navpath': navpath,
'title': create_title(navpath),
'system_metrics': system_metrics,
'netbox_availability': netbox_availability,
'graphite_error': graphite_error,
},
context_instance=RequestContext(request,
processors=[search_form_processor]))
def module_details(request, netbox_sysname, module_name):
"""Show detailed view of one IP device module"""
def get_module_view(module_object, perspective, activity_interval=None):
"""
Returns a dict structure with all ports on the module.
Arguments:
perspective -- decides what kind of ports are included.
activity_interval -- number of days to check for port activity.
"""
module = utils.get_module_view(
module_object, perspective, activity_interval)
if activity_interval is not None:
module['activity_interval'] = activity_interval
module['activity_interval_start'] = (
dt.datetime.now() - dt.timedelta(days=activity_interval))
# Check if we got data for the entire search interval
try:
module['activity_data_start'] = (
module_object.netbox.cam_set.order_by(
'start_time')[0].start_time)
module['activity_data_interval'] = (
dt.datetime.now() - module['activity_data_start']).days
module['activity_complete_data'] = (
module['activity_data_start'] <
module['activity_interval_start'])
except IndexError:
module['activity_data_start'] = None
module['activity_data_interval'] = 0
module['activity_complete_data'] = False
return module
# Get port activity search interval from form
activity_interval = 30
if 'interval' in request.GET:
activity_interval_form = ActivityIntervalForm(request.GET)
if activity_interval_form.is_valid():
activity_interval = activity_interval_form.cleaned_data[
'interval']
else:
activity_interval_form = ActivityIntervalForm(
initial={'interval': activity_interval})
module = get_object_or_404(Module.objects.select_related(depth=1),
netbox__sysname=netbox_sysname, name=module_name)
swportstatus_view = get_module_view(module, 'swportstatus')
swportactive_view = get_module_view(
module, 'swportactive', activity_interval)
gwportstatus_view = get_module_view(module, 'gwportstatus')
navpath = NAVPATH + [('Module Details',)]
return render_to_response(
'ipdevinfo/module-details.html',
{
'module': module,
'swportstatus_view': swportstatus_view,
'swportactive_view': swportactive_view,
'gwportstatus_view': gwportstatus_view,
'activity_interval_form': activity_interval_form,
'activity_interval': activity_interval,
'navpath': navpath,
'heading': navpath[-1][0],
'title': create_title(navpath)
},
context_instance=RequestContext(request,
processors=[search_form_processor]))
def _build_context(request):
nav_path = [('Home', '/'), ('Syslogger', reverse('logger_index'))]
results = []
context = {}
aggregates = {}
if len(request.GET.keys()) > 0:
query_dict = request.GET.copy()
form = LoggerGroupSearchForm(query_dict)
if form.is_valid():
results = LogMessage.objects.filter(time__gte=form.cleaned_data['timestamp_from'], time__lte=form.cleaned_data['timestamp_to']).select_related()
if 'priority' in form.cleaned_data and form.cleaned_data['priority']:
priority_keyword = form.cleaned_data['priority']
if not isinstance(form.cleaned_data['priority'], list):
priority_keyword = [form.cleaned_data['priority']]
results = results.filter(newpriority__keyword__in=priority_keyword)
if 'mnemonic' in form.cleaned_data and form.cleaned_data['mnemonic']:
message_type_mnemonic = form.cleaned_data['mnemonic']
if not isinstance(form.cleaned_data['mnemonic'], list):
message_type_mnemonic = [form.cleaned_data['mnemonic']]
results = results.filter(type__mnemonic__in=message_type_mnemonic)
if 'facility' in form.cleaned_data and form.cleaned_data['facility']:
message_type_facility = form.cleaned_data['facility']
if not isinstance(form.cleaned_data['facility'], list):
message_type_facility = [form.cleaned_data['facility']]
results = results.filter(type__facility__in=message_type_facility)
if form.cleaned_data["category"]:
categories = form.cleaned_data['category']
if not isinstance(form.cleaned_data['category'], list):
categories = [form.cleaned_data['category']]
results = results.filter(origin__category__in=categories)
if 'origin' in form.cleaned_data and form.cleaned_data['origin']:
origin_name = form.cleaned_data['origin']
if not isinstance(form.cleaned_data['origin'], list):
origin_name = [form.cleaned_data['origin']]
results = results.filter(origin__name__in=origin_name)
priorities = results.values('newpriority__keyword').annotate(sum=Count('newpriority__keyword'))
priorities_headers = ['Priority']
message_types = results.values('type__facility', 'type__priority__keyword', 'type__mnemonic').annotate(sum=Count('type'))
message_types_headers = ['Facility', 'Priority', 'State']
origins = results.values('origin__name').annotate(sum=Count('origin__name'))
origins_headers = ['Origin']
aggregates.update({'Priorities' : { 'values': priorities, 'headers': priorities_headers, 'colspan': 1} })
aggregates.update({'Type': { 'values': message_types, 'headers': message_types_headers, 'colspan': 3 }})
aggregates.update({'Origin': { 'values': origins, 'headers': origins_headers, 'colspan': 1 }})
def _update_show_log_context(value, results):
if value:
context.update({'log_messages': results})
context.update({'show_log': value})
form.data = form.data.copy() # mutable QueryDict, yes please
form.data['show_log'] = value
if 'show_log' in form.cleaned_data and form.cleaned_data['show_log']:
show_log = bool(form.cleaned_data['show_log'])
_update_show_log_context(show_log, results)
if len(priorities) <= 1 and len(origins) <= 1:
_update_show_log_context(True, results)
elif len(message_types) <= 1 and len(priorities) <= 1:
_update_show_log_context(True, results)
else:
initial_context = {
'timestamp_from': (datetime.datetime.now() -
datetime.timedelta(days=1)),
'timestamp_to': datetime.datetime.now()
}
form = LoggerGroupSearchForm(initial=initial_context)
strip_query_args = _strip_empty_arguments(request)
strip_query_args = strip_query_args.urlencode() if strip_query_args else ""
context.update({
'form': form,
'bookmark': "{0}?{1}".format(reverse(index), strip_query_args),
'aggregates': aggregates,
'timestamp': datetime.datetime.now().strftime(DATEFORMAT),
'domain_strip': simplejson.dumps(DOMAIN_SUFFICES),
'navpath': nav_path,
'title': create_title(nav_path)
})
return context
