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
