def view(view_type):
devices, parameters = fetch_all('Device'), get_one('Parameters').serialized
return dict(template=f'{view_type}_view.html',
pools=fetch_all('Pool'),
parameters=parameters,
view=request.form.get('view', parameters['default_view']),
google_earth_form=GoogleEarthForm(request.form),
add_device_form=AddDevice(request.form),
add_link_form=AddLink(request.form),
device_subtypes=device_subtypes,
link_colors=link_subtype_to_color,
name_to_id={d.name: id
for id, d in enumerate(devices)},
devices=serialize('Device'),
links=serialize('Link'))
def pool_management():
return dict(
form=AddPoolForm(request.form),
pool_object_form=PoolObjectsForm(request.form),
fields=pool_table_properties,
pools=serialize('Pool')
)
def workflow_management() -> dict:
return dict(
compare_logs_form=CompareLogsForm(request.form),
fields=workflow_table_properties,
workflows=serialize("Workflow"),
workflow_creation_form=JobForm(request.form),
)
def log_management():
log_filtering_form = LogFilteringForm(request.form)
return render_template('log_management.html',
log_filtering_form=log_filtering_form,
names=pretty_names,
fields=('source', 'content'),
logs=serialize('Log'))
def syslog_automation():
log_automation_form = LogAutomationForm(request.form)
log_automation_form.jobs.choices = choices('Job')
return render_template('log_automation.html',
log_automation_form=log_automation_form,
names=pretty_names,
fields=('name', 'source', 'content'),
log_rules=serialize('LogRule'))
def service_management() -> dict:
return dict(
compare_logs_form=CompareLogsForm(request.form),
fields=service_table_properties,
service_form=JobForm(request.form),
services_classes=list(service_classes),
services=serialize("Service"),
)
def device_management():
return dict(
fields=device_table_properties,
devices=serialize('Device'),
add_device_form=AddDevice(request.form),
device_automation_form=DeviceAutomationForm(request.form),
gotty_connection_form=GottyConnectionForm(request.form)
)
def configuration_management():
return dict(
fields=device_configuration_properties,
devices=serialize('Device'),
compare_configurations_form=CompareConfigurationsForm(request.form),
add_device_form=ConfigurationManagementForm(request.form),
gotty_connection_form=GottyConnectionForm(request.form),
poller_form=PollerForm(request.form),
search_configurations_form=SearchConfigurationForm(request.form))
def task_management():
scheduling_form = SchedulingForm(request.form)
scheduling_form.job.choices = choices('Job')
return render_template(
f'task_management.html',
fields=task_public_properties,
tasks=serialize('Task'),
scheduling_form=scheduling_form
)
def filter_logs():
logs = [
log for log in serialize('Log') if all(
request.form[prop] in str(val) if not prop +
'regex' in request.form else search(request.form[prop], str(val))
for prop, val in log.items()
if prop in request.form and request.form[prop])
]
return logs
def view(view_type: str) -> dict:
devices, parameters = fetch_all("Device"), get_one("Parameters").serialized
return dict(
template=f"{view_type}_view.html",
pools=fetch_all("Pool"),
parameters=parameters,
view=request.form.get("view", parameters["default_view"]),
google_earth_form=GoogleEarthForm(request.form),
add_device_form=AddDevice(request.form),
add_link_form=AddLink(request.form),
device_subtypes=device_subtypes,
gotty_connection_form=GottyConnectionForm(request.form),
link_colors=link_subtype_to_color,
name_to_id={d.name: id
for id, d in enumerate(devices)},
devices=serialize("Device"),
links=serialize("Link"),
)
def pool_management():
pool_object_form = PoolObjectsForm(request.form)
pool_object_form.devices.choices = choices('Device')
pool_object_form.links.choices = choices('Link')
return render_template('pool_management.html',
form=AddPoolForm(request.form),
pool_object_form=pool_object_form,
names=pretty_names,
fields=pool_table_properties,
pools=serialize('Pool'))
def link_management():
add_link_form = AddLink(request.form)
devices = [(l.name, l.name) for l in fetch_all('Device')]
add_link_form.source_name.choices = devices
add_link_form.destination_name.choices = devices
return render_template('link_management.html',
names=pretty_names,
fields=link_table_properties,
links=serialize('Link'),
add_link_form=add_link_form)
def export_topology():
workbook = Workbook()
for obj_type in ('Device', 'Link'):
sheet = workbook.add_sheet(obj_type)
for index, property in enumerate(export_properties[obj_type]):
sheet.write(0, index, property)
for obj_index, obj in enumerate(serialize(obj_type), 1):
sheet.write(obj_index, index, obj[property])
workbook.save(Path.cwd() / 'projects' / 'objects.xls')
return jsonify(True)
def object_export(request, path_app):
workbook = Workbook()
for obj_type in ('Device', 'Link'):
sheet = workbook.add_sheet(obj_type)
for index, property in enumerate(export_properties[obj_type]):
sheet.write(0, index, property)
for obj_index, obj in enumerate(serialize(obj_type), 1):
sheet.write(obj_index, index, obj[property])
workbook.save(path_app / 'projects' / f'{request["name"]}.xls')
return True
def object_export(request: dict, path_app: PosixPath) -> bool:
workbook = Workbook()
for obj_type in ("Device", "Link"):
sheet = workbook.add_sheet(obj_type)
for index, property in enumerate(export_properties[obj_type]):
sheet.write(0, index, property)
for obj_index, obj in enumerate(serialize(obj_type), 1):
sheet.write(obj_index, index, obj[property])
workbook.save(path_app / "projects" / f'{request["export_filename"]}.xls')
return True
def view(view_type):
devices = fetch_all('Device')
add_link_form = AddLink(request.form)
form_devices = [(l.name, l.name) for l in fetch_all('Device')]
add_link_form.source_name.choices = form_devices
add_link_form.destination_name.choices = form_devices
labels = {'device': 'name', 'link': 'name'}
if 'view_options' in request.form:
labels = {
'device': request.form['device_label'],
'link': request.form['link_label']
}
if len(devices) < 50:
view = 'glearth'
elif len(devices) < 2000:
view = 'leaflet'
else:
view = 'markercluster'
if 'view' in request.form:
view = request.form['view']
name_to_id = {device.name: id for id, device in enumerate(devices)}
return render_template(f'{view_type}_view.html',
pools=fetch_all('Pool'),
parameters=get_one('Parameters').serialized,
view=view,
view_options_form=ViewOptionsForm(request.form),
google_earth_form=GoogleEarthForm(request.form),
add_device_form=AddDevice(request.form),
add_link_form=add_link_form,
device_fields=device_public_properties,
link_fields=link_public_properties,
labels=labels,
names=pretty_names,
device_subtypes=device_subtypes,
link_colors=link_subtype_to_color,
name_to_id=name_to_id,
devices=serialize('Device'),
links=serialize('Link'))
def filter_logs():
logs = [
log for log in serialize('Log') if all(
# if the regex property is not in the request, the
# regex box is unticked and we only check that the values of the
# filters are contained in the values of the log
request.form[prop] in str(val) if not prop +
'regex' in request.form
# if it is ticked, we use re.search to check that the value
# of the device property matches the regular expression,
# providing that the property field in the form is not empty
# (empty field <==> property ignored)
else search(request.form[prop], str(val))
for prop, val in log.items()
if prop in request.form and request.form[prop])
]
return jsonify(logs)
def device_management():
return render_template('device_management.html',
names=pretty_names,
fields=device_public_properties,
devices=serialize('Device'),
add_device_form=AddDevice(request.form))
def user_management() -> dict:
return dict(
fields=user_table_properties,
users=serialize("User"),
form=AddUser(request.form),
)
def link_management():
return dict(
fields=link_table_properties,
links=serialize('Link'),
add_link_form=AddLink(request.form)
)
def device_management():
return dict(fields=device_public_properties,
devices=serialize('Device'),
add_device_form=AddDevice(request.form),
device_automation_form=DeviceAutomationForm(request.form))
def log_management() -> dict:
return dict(fields=log_public_properties, logs=serialize("Log"))
def log_automation() -> dict:
return dict(
log_automation_form=LogAutomationForm(request.form),
fields=log_rule_table_properties,
log_rules=serialize("LogRule"),
)
def log_automation():
return dict(log_automation_form=LogAutomationForm(request.form,
prefix='logrule-'),
fields=('name', 'source', 'content'),
log_rules=serialize('LogRule'))
def users():
return render_template('user_management.html',
fields=user_public_properties,
names=pretty_names,
users=serialize('User'),
form=AddUser(request.form))
def log_management():
return dict(log_filtering_form=LogFilteringForm(request.form),
fields=('source', 'content'),
logs=serialize('Log'))
def instance_management() -> dict:
return dict(
fields=instance_table_properties,
instances=serialize("Instance"),
form=AddInstance(request.form),
)
def task_management():
return dict(fields=task_public_properties,
tasks=serialize('Task'),
scheduling_form=SchedulingForm(request.form))
def log_management():
return dict(fields=log_public_properties, logs=serialize('Log'))
