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