def repr_yml(self, py_repr, **kwargs): tgt_particle = kwargs.get("tgt_particle") target_cell = kwargs.get("target_cell", kwargs.get("deployed_cell")) if target_cell is not None: kwargs["psk_cells"] = [py_repr.name, target_cell.id.name] public_only = (kwargs.get("public_only") or (tgt_particle is not None and tgt_particle != py_repr.name) or target_cell is not None) kwargs["public_only"] = public_only yml_repr = { "name": py_repr.name, "n": py_repr.n, "contact": py_repr.contact, "psks": repr_yml(py_repr.psks, **kwargs), "keymat": repr_yml(py_repr.keymat, **kwargs) } if kwargs.get("manifest"): yml_repr["configs"] = [ repr_yml(c, **kwargs) for c in py_repr.configs.values() ] return yml_repr
def repr_yml(self, py_repr, **kwargs): tgt_cell_cfg = kwargs.get("tgt_cell_cfg") if (tgt_cell_cfg is not None): tgt_cells = list( itertools.chain((c.deploy_id for c in tgt_cell_cfg.peers), [tgt_cell_cfg.deploy_id])) else: tgt_cells = [c.deploy_id for c in py_repr.deployed_cells] deployment_id = kwargs.get("deployment_id") if (deployment_id is None): deployment_id = py_repr.id yml_repr = dict() yml_repr["id"] = deployment_id yml_repr["strategy"] = repr_yml(py_repr.strategy, **kwargs) yml_repr["deploy_time"] = repr_yml(py_repr.deploy_time, **kwargs) yml_repr["cells"] = [c.id.name for c in py_repr.cells] yml_repr["psks"] = repr_yml(py_repr.psks, psk_cells=tgt_cells, **kwargs) yml_repr["deployed_cells"] = [ repr_yml(c, deployment=py_repr, **kwargs) for c in py_repr.deployed_cells if c.deploy_id in tgt_cells ] yml_repr["address_range"] = tuple(map(str, py_repr.address_range)) return yml_repr
def repr_yml(self, py_repr, **kwargs): tgt_cell = kwargs.get("tgt_cell") public_only = (kwargs.get("public_only") or (tgt_cell is not None and tgt_cell != py_repr.id.name)) kwargs["public_only"] = public_only yml_repr = dict() yml_repr["id"] = repr_yml(py_repr.id, **kwargs) yml_repr["peer_ports"] = py_repr.peer_ports if (public_only): registry_psk = '' registry_vpn = '' router_port = '' else: registry_psk = py_repr.registry_psk registry_vpn = repr_yml(py_repr.registry_vpn, **kwargs) router_port = repr_yml(py_repr.router_port, **kwargs) yml_repr["registry_psk"] = registry_psk yml_repr["registry_vpn"] = registry_vpn yml_repr["router_port"] = router_port return yml_repr
def repr_yml(self, py_repr, **kwargs): # These values are currently ignored by the generated configuration allowed_ips = [ "{}/{}".format( py_repr.cell.router_port.addr_remote, UvnDefaults["registry"]["vpn"]["router"]["netmask"]) ] allowed_ips.extend( UvnDefaults["registry"]["vpn"]["router"]["allowed_ips"]) return { "registry": repr_yml(py_repr.registry, target_cell=py_repr.cell, deployment_id=None, **kwargs), "identity_db": repr_yml(py_repr.registry.identity_db, target_cell=py_repr.cell, deployment_id=None, **kwargs), "cell": repr_yml(py_repr.cell, **kwargs), "allowed_ips": allowed_ips }
def repr_yml(self, py_repr, **kwargs): yml_repr = dict() if (py_repr._last_activity is not None): yml_repr["last_activity"] = repr_yml( py_repr._last_activity, **kwargs) yml_repr["activity_timeout"] = repr_yml( py_repr._activity_timeout, **kwargs) yml_repr["active"] = py_repr.is_active() return yml_repr
def repr_yml(self, py_repr, **kwargs): target_cell = kwargs.get("target_cell") deployed_cell = kwargs.get("deployed_cell") if deployed_cell is None: deployed_cell = py_repr.pkg_cell public_only = (kwargs.get("public_only") or deployed_cell is not None or target_cell is not None) if public_only: if deployed_cell is not None: if isinstance(deployed_cell, str): pkg_cell = deployed_cell else: pkg_cell = deployed_cell.cell.id.name elif target_cell is not None: pkg_cell = target_cell.id.name else: pkg_cell = "<some-unknown-cell>" else: pkg_cell = None if deployed_cell is not None: deployment_id = kwargs["deployment_id"] deployments = [deployment_id] elif target_cell is not None: deployment_id = kwargs["deployment_id"] deployments = [] else: deployment_id = None deployments = [d.id for d in py_repr.deployments] kwargs["public_only"] = public_only kwargs["pkg_cell"] = pkg_cell yml_repr = dict() yml_repr["ports"] = py_repr.ports yml_repr["cells"] = [ repr_yml(c, **kwargs) for c in py_repr.cells.values() ] yml_repr["particles"] = [ repr_yml(p, **kwargs) for p in py_repr.particles.values() ] # yml_repr["ns"] = repr_yml(py_repr.nameserver, **kwargs) yml_repr["keymat"] = repr_yml(py_repr.keymat, **kwargs) if py_repr.vpn_config is not None and not public_only: yml_repr["vpn_config"] = repr_yml(py_repr.vpn_config, **kwargs) yml_repr["router_ports"] = repr_yml(py_repr.router_ports, **kwargs) yml_repr["deployments"] = deployments if pkg_cell is not None: yml_repr["pkg_cell"] = pkg_cell if deployment_id is not None: yml_repr["deployment_id"] = deployment_id return yml_repr
def repr_yml(self, py_repr, **kwargs): yml_repr = dict() yml_repr["interface"] = py_repr.interface yml_repr["endpoint"] = py_repr.endpoint yml_repr["port"] = py_repr.port yml_repr["network"] = str(py_repr.network) yml_repr["addr_local"] = str(py_repr.addr_local) yml_repr["keymat"] = repr_yml(py_repr.keymat, **kwargs) yml_repr["peers"] = [ repr_yml(p, **kwargs) for p in py_repr.particles.values() ] return yml_repr
def repr_yml(self, py_repr, **kwargs): # These values are currently ignored by the generated configuration allowed_ips = [ "{}/{}".format( py_repr.cell.router_port.addr_local, UvnDefaults["registry"]["vpn"]["router"]["netmask"]) ] allowed_ips.extend( UvnDefaults["registry"]["vpn"]["router"]["allowed_ips"]) return { "registry": repr_yml(py_repr.registry, **kwargs), "cell": repr_yml(py_repr.cell, **kwargs), "allowed_ips": allowed_ips }
def _repr_ctx_zebra_conf(self): parent = { "hostname": self._hostname(), "timeout": dict(UvnDefaults["router"]["timeout"]), "log": UvnDefaults["router"]["zebra"]["log"], "log_level": UvnDefaults["router"]["zebra"]["log_level"], "root": { "name": self.vpn.wg_root.interface, "address": self.vpn.wg_root.interface_address, "mask": self.vpn.wg_root.interface_address_mask }, "router": [{ "name": wg.interface, "address": wg.interface_address, "mask": wg.interface_address_mask } for wg in self.vpn.wg_router], "static_routes": repr_yml(self._static_routes) } parent.update({ "lans": [{ "name": net["nic"], "address": str(net["address"]), "mask": net["mask"] } for net in self.vpn.list_local_networks()] }) if self.cell_cfg: parent.update({ "backbone": [{ "name": bbone.interface, "address": str(bbone.addr_local), "mask": UvnDefaults["registry"]["vpn"]["backbone2"]["netmask"], "subnet": str(bbone.network), "area": str(bbone.network.network_address), "area_int": int(bbone.network.network_address), "peers": repr_yml(bbone.peers) } for bbone_i, bbone in enumerate(self.cell_cfg.backbone)] }) return parent
def repr_yml(self, py_repr, **kwargs): tgt_cell_cfg = kwargs.get("tgt_cell_cfg") public_only = (tgt_cell_cfg is not None and tgt_cell_cfg.cell.id.name != py_repr.cell.id.name) yml_repr = dict() yml_repr["cell"] = py_repr.cell.id.name yml_repr["deploy_id"] = py_repr.deploy_id yml_repr["peers"] = [repr_yml(p, **kwargs) for p in py_repr.peers] yml_repr["backbone"] = [ repr_yml(p, **kwargs) for p in py_repr.backbone ] return yml_repr
def repr_yml(self, py_repr, **kwargs): export_all = kwargs.get("export_all", False) if export_all: exported = py_repr.db.items() else: exported = py_repr.exported() return {"db": {k: repr_yml(v, **kwargs) for k, v in exported}}
def repr_yml(self, py_repr, **kwargs): yml_repr = {} yml_repr["registry"] = repr_yml(py_repr.registry, **kwargs) yml_repr["identity_db"] = repr_yml(py_repr.registry.identity_db, **kwargs) yml_repr["deployment"] = repr_yml(py_repr.deployment, **kwargs) def get_cell_by_name(registry, name): return next( iter([ c for c in registry["cells"] if c["id"]["name"] == name ])) def get_cell_public_key_by_name(name): return py_repr.registry.identity_db.get_cell_record( name).key.fingerprint # def get_cell_port(cell_cfg, peer_id): # return int(cell_cfg["peers"][peer_id].split(":")[0]) def get_peer_port(cell_cfg, peer_id): return int(cell_cfg["peers"][peer_id].split(":")[2]) def _extract_deployed_cell_name(cell): return cell["name"] def _extract_deployed_cell_registration_id(cell): return get_cell_by_name(yml_repr["registry"], cell["cell"])["id"]["n"] def sort_deployed_cells(deployed_cells): return sorted(deployed_cells, key=_extract_deployed_cell_registration_id) # def enumerate_peers(cell_cfg, peers): # def _extract_local_port(peerentry): # return get_cell_port(cell_cfg, peerentry[0]) # return sorted(enumerate(peers), key=_extract_local_port) yml_repr[ "get_cell_public_key_by_name"] = get_cell_public_key_by_name yml_repr["get_cell_by_name"] = get_cell_by_name # yml_repr["get_cell_port"] = get_cell_port yml_repr["get_peer_port"] = get_peer_port yml_repr["sort_deployed_cells"] = sort_deployed_cells # yml_repr["enumerate_peers"] = enumerate_peers yml_repr["enumerate"] = enumerate return yml_repr
def _stat_router(self): return { "networks": {n.handle: repr_yml(n) for n in self._agent.router}, "services": { "quagga": self._agent.router._quagga is not None, "monitor": self._agent.router._monitor is not None } }
def repr_yml(self, py_repr, **kwargs): yml_repr = dict() yml_repr["name"] = py_repr.name yml_repr["n"] = py_repr.n yml_repr["address"] = py_repr.address yml_repr["location"] = py_repr.location yml_repr["admin"] = py_repr.admin yml_repr["admin_name"] = py_repr.admin_name yml_repr["keymat"] = repr_yml(py_repr.keymat, **kwargs) return yml_repr
def repr_yml(self, py_repr, **kwargs): return { "interface": py_repr.interface, "registry_endpoint": py_repr.registry_endpoint, "registry_address": str(py_repr.registry_address), "registry_port": py_repr.registry_port, "registry_pubkey": py_repr.registry_pubkey, "registry_privkey": py_repr.registry_privkey, "peers": [repr_yml(p, **kwargs) for p in py_repr.peers] }
def repr_yml(self, py_repr, **kwargs): target_cell = kwargs.get("tgt_cell") public_only = target_cell is not None or kwargs.get("public_only") if target_cell: tgt_cells = [py_repr.allocated[target_cell].cell_n] else: tgt_cells = [p.cell_n for p in py_repr.allocated.values()] kwargs = dict(kwargs) kwargs["public_only"] = public_only yml_repr = { "min": py_repr.min, "max": py_repr.max, "reserved": py_repr.reserved, "allocated": { k: repr_yml(p, tgt_cells=tgt_cells, **kwargs) for k, p in py_repr.allocated.items() }, "psks": repr_yml(py_repr.psks, psk_cells=tgt_cells, **kwargs), "keymat": repr_yml(py_repr.keymat, **kwargs) } return yml_repr
def _stat_vpn(self): res = { "interfaces": { "registry": repr_yml(self._agent.vpn.wg_root), "backbone": { wg.interface: repr_yml(wg) for wg in self._agent.vpn.wg_backbone }, "router": { wg.interface: repr_yml(wg) for wg in self._agent.vpn.wg_router } }, "local_networks": [{k: str(v) for k, v in n.items()} for n in self._agent.vpn._nat_nets] } if hasattr(self._agent.vpn, "wg_particles"): res["interfaces"]["particles"] = { self._agent.vpn.wg_particles.interface: repr_yml(self._agent.vpn.wg_particles) } return res
def repr_yml(self, py_repr, **kwargs): tgt_cells = kwargs.get("tgt_cells", None) public_only = tgt_cells is not None and py_repr.cell_n not in tgt_cells kwargs = dict(kwargs) kwargs["public_only"] = public_only return { "cell_n": py_repr.cell_n, "n": py_repr.n, "psk": py_repr.psk if not public_only else "", "keymat": repr_yml(py_repr.keymat, **kwargs), "registry_pubkey": py_repr.registry_pubkey, "addr_local": str(py_repr.addr_local), "addr_remote": str(py_repr.addr_remote), "interface": py_repr.interface, "area": py_repr.area }
def _repr_ctx_zebra_conf(self): return { "hostname": self._hostname(), "timeout": dict(UvnDefaults["router"]["timeout"]), "log": UvnDefaults["router"]["zebra"]["log"], "log_level": UvnDefaults["router"]["zebra"]["log_level"], "root": { "name": self.vpn.wg_root.interface, "address": self.vpn.wg_root.interface_address, "mask": self.vpn.wg_root.interface_address_mask }, "router": [{ "name": wg.interface, "address": wg.interface_address, "mask": wg.interface_address_mask } for wg in self.vpn.wg_router], "static_routes": repr_yml(self._static_routes) }
def repr_yml(self, py_repr, **kwargs): if (kwargs.get("public_only")): cell_privkey = "" interface = "" else: cell_privkey = py_repr.cell_privkey interface = py_repr.interface yml_repr = dict() yml_repr["cell_name"] = py_repr.cell_name yml_repr["cell_pubkey"] = py_repr.cell_pubkey yml_repr["cell_privkey"] = cell_privkey yml_repr["interface"] = interface yml_repr["net_cell_n"] = py_repr.net_cell_n yml_repr["port_i"] = py_repr.port_i yml_repr["port_local"] = py_repr.port_local yml_repr["addr_local"] = str(py_repr.addr_local) yml_repr["network_local"] = str(py_repr.network_local) yml_repr["network"] = str(py_repr.network) yml_repr["network_mask"] = str(py_repr.network_mask) yml_repr["peers"] = [ repr_yml(p, **kwargs) for p in py_repr.peers ] return yml_repr
def repr_ctx(self, obj, repr, repr_tmplt, **kwargs): return repr_yml(obj, repr=repr, repr_tmplt=repr_tmplt, **kwargs)
def repr_yml(self, py_repr, **kwargs): yml_repr = dict() yml_repr["peers"] = [repr_yml(k, **kwargs) for k in py_repr] yml_repr["registry"] = repr_yml(py_repr.registry, **kwargs) yml_repr["particles"] = repr_yml(py_repr.particles, **kwargs) return yml_repr
def _stat_peers(self): return {p.cell.id.name: repr_yml(p) for p in self._agent._peers}
def _repr_ctx_ospfd_conf(self): parent = { "md5key": UvnDefaults["router"]["ospfd"]["md5key"], "router_area": UvnDefaults["router"]["ospfd"]["area"], "router_id": str(self.vpn.wg_root.interface_address), "timeout": dict(UvnDefaults["router"]["timeout"]), "log": UvnDefaults["router"]["ospfd"]["log"], "log_level": UvnDefaults["router"]["ospfd"]["log_level"], "root": { "name": self.vpn.wg_root.interface, "address": self.vpn.wg_root.interface_address, "mask": self.vpn.wg_root.interface_address_mask }, "router": [{ "name": wg.interface, "address": wg.interface_address, "mask": wg.interface_address_mask, "area": self.registry.router_ports.cell_area(self.cell.id.n) } for wg in self.vpn.wg_router] } if not self.roaming: parent.update({ "lans": [{ "name": net["nic"], "address": str(net["address"]), "mask": net["mask"], "subnet": str(net["subnet"]), "area": str(net["subnet"].network_address) } for net in self.vpn.list_local_networks()] }) if self.cell_cfg: parent.update({ "backbone": [{ "name": bbone.interface, "address": str(bbone.addr_local), "mask": UvnDefaults["registry"]["vpn"]["backbone2"]["netmask"], "subnet": str("{}/{}".format( bbone.network.network_address, UvnDefaults["registry"] ["vpn"]["backbone2"]["netmask"])), "area": str(bbone.network.network_address), "area_int": int(bbone.network.network_address), "peers": repr_yml(bbone.peers) } for bbone_i, bbone in enumerate(self.cell_cfg.backbone)] }) return parent