def connection(device_id: int) -> dict:
parameters, device = get_one("Parameters"), fetch("Device", id=device_id)
cmd = [str(app.path / "applications" / "gotty"), "-w"]
port, protocol = parameters.get_gotty_port(), request.form["protocol"]
address = getattr(device, request.form["address"])
cmd.extend(["-p", str(port)])
if "accept-once" in request.form:
cmd.append("--once")
if "multiplexing" in request.form:
cmd.extend(f"tmux new -A -s gotty{port}".split())
if app.config["GOTTY_BYPASS_KEY_PROMPT"]:
options = "-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
else:
options = ""
if protocol == "telnet":
cmd.extend(f"telnet {address}".split())
elif "authentication" in request.form:
if request.form["credentials"] == "device":
login, pwd = device.username, device.password
else:
login, pwd = current_user.name, current_user.password
cmd.extend(f"sshpass -p {pwd} ssh {options} {login}@{address}".split())
else:
cmd.extend(f"ssh {options} {address}".split())
if protocol != "telnet":
cmd.extend(f"-p {device.port}".split())
Popen(cmd)
return {
"device": device.name,
"port": port,
"redirection": app.config["GOTTY_PORT_REDIRECTION"],
"server_addr": app.config["ENMS_SERVER_ADDR"],
}
def scheduler_job(
job_id: int,
aps_job_id: Optional[str] = None,
targets: Optional[Set[Device]] = None,
payload: Optional[dict] = None,
) -> None:
with controller.app.app_context():
task = fetch("Task", creation_time=aps_job_id)
job = fetch("Job", id=job_id)
if targets:
targets = {fetch("Device", id=device_id) for device_id in targets}
results, now = job.try_run(targets=targets, payload=payload)
parameters = get_one("Parameters")
if job.push_to_git and parameters.git_automation:
path_git_folder = Path.cwd() / "git" / "automation"
with open(path_git_folder / job.name, "w") as file:
file.write(str_dict(results))
repo = Repo(str(path_git_folder))
try:
repo.git.add(A=True)
repo.git.commit(m=f"Automatic commit ({job.name})")
except GitCommandError:
pass
repo.remotes.origin.push()
if task and not task.frequency:
task.is_active = False
db.session.commit()
def mail_feedback_notification(self, payload: dict) -> dict:
parameters = get_one("Parameters")
name = f"{payload['job']['name']}"
recipients = payload["job"]["mail_recipient"].split(
",") or parameters.mail_recipients.split(",")
self.logs.append(f"Sending mail notification for {name}")
message = Message(
f"{name} ({'PASS' if payload['result'] else 'FAILED'})",
sender=parameters.mail_sender,
recipients=recipients,
body=payload["content"],
)
runtime = payload["runtime"].replace(".", "").replace(":", "")
filename = f"results-{runtime}.txt"
with open(filename, "w") as file:
file.write(str_dict(payload["results"][payload["runtime"]]))
with open(filename, "r") as file:
message.attach(
filename,
"text/plain",
file.read(),
disposition=f"attachment; filename={filename}",
)
remove(filename)
mail_client.send(message)
return {"success": True}
def job(self, _) -> dict:
parameters = get_one("Parameters")
slack_client = SlackClient(self.token or parameters.slack_token)
channel = self.channel or parameters.slack_channel
self.logs.append(f"Sending Slack notification on {channel}")
result = slack_client.api_call(
"chat.postMessage", channel=channel, text=self.body
)
return {"success": True, "result": str(result)}
def import_export() -> dict:
return dict(
import_export_form=ImportExportForm(request.form),
librenms_form=LibreNmsForm(request.form),
netbox_form=NetboxForm(request.form),
opennms_form=OpenNmsForm(request.form),
google_earth_form=GoogleEarthForm(request.form),
parameters=get_one("Parameters"),
)
def job(self, _) -> dict:
parameters = get_one("Parameters")
channel = self.channel or parameters.mattermost_channel
self.logs.append(f"Sending Mattermost notification on {channel}")
result = post(
parameters.mattermost_url,
verify=parameters.mattermost_verify_certificate,
data=dumps({"channel": channel, "text": self.body}),
)
return {"success": True, "result": str(result)}
def create_default(app: Flask) -> None:
create_default_parameters(app)
parameters = get_one("Parameters")
create_default_users()
create_default_pools()
create_default_services()
create_default_workflows()
create_default_tasks(app)
parameters.trigger_active_parameters(app)
db.session.commit()
def slack_feedback_notification(self, payload: dict) -> dict:
parameters = get_one("Parameters")
slack_client = SlackClient(parameters.slack_token)
self.logs.append(f"Sending Slack notification for {payload['job']['name']}")
result = slack_client.api_call(
"chat.postMessage",
channel=parameters.slack_channel,
text=str_dict(payload["content"]),
)
return {"success": True, "result": str(result)}
def cluster_monitoring(self, payload: dict) -> dict:
parameters = get_one("Parameters")
protocol = parameters.cluster_scan_protocol
for instance in fetch_all("Instance"):
factory(
"Instance",
**get(
f"{protocol}://{instance.ip_address}/rest/is_alive",
timeout=parameters.cluster_scan_timeout,
).json(),
)
return {"success": True}
def git_push_configurations(self, payload: dict) -> dict:
parameters = get_one("Parameters")
if parameters.git_configurations:
repo = Repo(Path.cwd() / "git" / "configurations")
try:
repo.remotes.origin.pull()
repo.git.add(A=True)
repo.git.commit(m="Automatic commit (configurations)")
except GitCommandError as e:
info(f"Git commit failed ({str(e)}")
repo.remotes.origin.push()
return {"success": True}
def mattermost_feedback_notification(self, payload: dict) -> dict:
parameters = get_one("Parameters")
self.logs.append(
f"Sending Mattermost notification for {payload['job']['name']}")
post(
parameters.mattermost_url,
verify=parameters.mattermost_verify_certificate,
data=dumps({
"channel": parameters.mattermost_channel,
"text": payload["content"]
}),
)
return {"success": True}
def job(self, _) -> dict:
parameters = get_one("Parameters")
if self.recipients:
recipients = self.recipients.split(",")
else:
recipients = parameters.mail_sender.split(",")
sender = self.sender or parameters.mail_sender
self.logs.append(f"Sending mail {self.title} to {sender}")
message = Message(
self.title, sender=sender, recipients=recipients, body=self.body
)
mail_client.send(message)
return {"success": True, "result": str(message)}
def view(view_type: str) -> dict:
parameters = get_one("Parameters").serialized
return dict(
add_pool_form=AddPoolForm(request.form),
template=f"geographical_view.html",
parameters=parameters,
add_device_form=AddDevice(request.form),
add_link_form=AddLink(request.form),
device_automation_form=DeviceAutomationForm(request.form),
subtype_sizes=subtype_sizes,
gotty_connection_form=GottyConnectionForm(request.form),
link_colors=link_subtype_to_color,
pool_restriction_form=PoolRestrictionForm(request.form),
view_type=view_type,
)
def query_opennms() -> bool:
parameters = get_one("Parameters")
login, password = parameters.opennms_login, request.form["password"]
parameters.update(**request.form)
db.session.commit()
json_devices = http_get(
parameters.opennms_devices,
headers={
"Accept": "application/json"
},
auth=(login, password),
).json()["node"]
devices = {
device["id"]: {
"name": device.get("label", device["id"]),
"description": device["assetRecord"].get("description", ""),
"location": device["assetRecord"].get("building", ""),
"vendor": device["assetRecord"].get("manufacturer", ""),
"model": device["assetRecord"].get("modelNumber", ""),
"operating_system": device.get("operatingSystem", ""),
"os_version": device["assetRecord"].get("sysDescription", ""),
"longitude": device["assetRecord"].get("longitude", 0.0),
"latitude": device["assetRecord"].get("latitude", 0.0),
"subtype": request.form["subtype"],
}
for device in json_devices
}
for device in list(devices):
link = http_get(
f"{parameters.opennms_rest_api}/nodes/{device}/ipinterfaces",
headers={
"Accept": "application/json"
},
auth=(login, password),
).json()
for interface in link["ipInterface"]:
if interface["snmpPrimary"] == "P":
devices[device]["ip_address"] = interface["ipAddress"]
factory("Device", **devices[device])
db.session.commit()
return True
def scan_cluster() -> bool:
parameters = get_one("Parameters")
protocol = parameters.cluster_scan_protocol
for ip_address in IPv4Network(parameters.cluster_scan_subnet):
try:
instance = rest_get(
f"{protocol}://{ip_address}/rest/is_alive",
timeout=parameters.cluster_scan_timeout,
).json()
if app.config["CLUSTER_ID"] != instance.pop("cluster_id"):
continue
factory("Instance", **{
**instance,
**{
"ip_address": str(ip_address)
}
})
except ConnectionError:
continue
db.session.commit()
return True
def save_parameters() -> bool:
parameters = get_one("Parameters")
parameters.update(**request.form)
parameters.trigger_active_parameters(app)
db.session.commit()
return True
def administration() -> dict:
return dict(
form=AdministrationForm(request.form),
parameters=get_one("Parameters").serialized,
)
def git_action() -> bool:
parameters = get_one("Parameters")
parameters.get_git_content(app)
return True
