1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
# $Id$
import rpki.resource_set, os, yaml
class allocation_db(list):
def __init__(self, yaml):
self.root = allocation(yaml, self)
assert self.root.is_root()
self.root.closure()
self.map = dict((a.name, a) for a in self)
for i, a in zip(range(len(self)), self):
a.number = i
def get(self, name, default = None):
return self.map.get(name, default)
def apply_delta(self, delta):
for d in delta:
self.map[d["name"]].apply_delta(d)
self.root.closure()
class allocation(object):
parent = None
def __init__(self, yaml, db, parent = None):
db.append(self)
self.name = yaml["name"]
self.parent = parent
self.kids = [allocation(k, db, self) for k in yaml.get("kids", ())]
self.base = rpki.resource_set.resource_bag(
as = rpki.resource_set.resource_set_as(yaml.get("asn")),
v4 = rpki.resource_set.resource_set_ipv4(yaml.get("ipv4")),
v6 = rpki.resource_set.resource_set_ipv6(yaml.get("ipv6")))
def closure(self):
"""Compute the transitive resource closure for one resource attribute."""
resources = self.base
for kid in self.kids:
resources = resources.union(kid.closure())
self.resources = resources
return resources
def apply_delta(self, yaml):
for k,v in yaml.items():
if k != "name":
getattr(self, "apply_" + k)(v)
def apply_add_as(self, text):
self.base.as = self.base.as.union(rpki.resource_set.resource_set_as(text))
def apply_add_v4(self, text):
self.base.v4 = self.base.v4.union(rpki.resource_set.resource_set_ipv4(text))
def apply_add_v6(self, text):
self.base.v6 = self.base.v6.union(rpki.resource_set.resource_set_ipv6(text))
def apply_sub_as(self, text):
self.base.as = self.base.as.difference(rpki.resource_set.resource_set_as(text))
def apply_sub_v4(self, text):
self.base.v4 = self.base.v4.difference(rpki.resource_set.resource_set_ipv4(text))
def apply_sub_v6(self, text):
self.base.v6 = self.base.v6.difference(rpki.resource_set.resource_set_ipv6(text))
def dict(self):
return { "name" : self.name,
"as" : self.resources.as,
"v4" : self.resources.v4,
"v6" : self.resources.v6,
"number" : str(self.number) }
def is_leaf(self):
return not self.kids
def is_root(self):
return self.parent is None
def is_twig(self):
return self.parent is not None and self.kids
def write_conf(self):
if self.is_twig():
f = open(self.name + ".conf", "w")
f.write(conf_fmt % self.dict())
f.close()
def write_yaml(self):
if self.is_leaf():
f = open(self.name + ".yaml", "w")
f.write(yaml_fmt % self.dict())
f.close()
dump_fmt = '''\
#: %(number)s
Name: %(name)s
ASN: %(as)s
IPv4: %(v4)s
IPv6: %(v6)s
'''
def dump():
for a in db:
print dump_fmt % a.dict()
y = [y for y in yaml.safe_load_all(open("testdb2.yaml"))]
print "Loading", str(y[0]), "\n"
db = allocation_db(y[0])
dump()
for delta in y[1:]:
print "Applying delta", str(delta), "\n"
db.apply_delta(delta)
dump()
# Steps we need to take here
#
# 1: Construct config files for RPKId and IRDB instances
# 2: Initialize sql for RPKI and IRDB instances
# 3: Construct biz keys and certs for RPKI and IRDB instances
# 4: Populate IRDB(s)
# 5: Start RPKI and IRDB instances
# 6: Create objects in RPKI engines
# 7: Write YAML files for leaves
# 8: Start cycle:
# 8a: Run cron in all RPKI instances
# 8b: Run all YAML clients
# 8c: Read and apply next deltas from master YAML
#
# This is going to be ugly
|
