def test_dict_merge_src_unchanged():
base = {
"flist": [
{
"dir": "out",
"rmap": "rmap_1"
},
{
"dir": "in",
"rmap": "rmap_2"
},
]
}
basecp = deepcopy(base)
other = {
"flist": [
{
"dir": "out",
"rmap": "rmap_12"
},
{
"dir": "in",
"rmap": "rmap_2"
},
]
}
othercp = deepcopy(other)
utils.dict_merge(base, other)
# dict_merge() should not modify the source dicts
assert base == basecp
assert other == othercp
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
wantd = {(entry["process_id"]): entry
for entry in self.want.get("processes", [])}
haved = {(entry["process_id"]): entry
for entry in self.have.get("processes", [])}
# turn all lists of dicts into dicts prior to merge
for entry in wantd, haved:
self._ospfv3_list_to_dict(entry)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
haved = {
k: v
for k, v in iteritems(haved) if k in wantd or not wantd
}
wantd = {}
# if state is overridden, first remove processes that are in have but not in want
if self.state in ["overridden", "deleted"]:
for k, have in iteritems(haved):
if k not in wantd:
self.addcmd(have, "process_id", True)
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
if self.want:
wantd = {}
for each in self.want:
wantd.update({each["name"]: each})
else:
wantd = {}
if self.have:
haved = {}
for each in self.have:
haved.update({each["name"]: each})
else:
haved = {}
for each in wantd, haved:
self.list_to_dict(each)
if self.state == "merged":
wantd = dict_merge(haved, wantd)
if self.state == "deleted":
haved = {k: v for k, v in haved.items() if k in wantd or not wantd}
wantd = {}
# remove superfluous config
if self.state in ["overridden", "deleted"]:
for k, have in haved.items():
if k not in wantd:
self._compare(want={}, have=have)
for k, want in wantd.items():
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
if self.want:
wantd = self.list_to_dict(self.want, "want")
else:
wantd = dict()
if self.have:
haved = self.list_to_dict(self.have, "have")
else:
haved = dict()
if self.state in ["overridden", "replaced"]:
if wantd != haved:
wantx, havex = self.call_op(wantd, haved, "overridden")
for k, have in iteritems(havex):
if k not in wantx:
self._compare(want={}, have=have)
if not self.state == "deleted":
wantd, haved = self.call_op(wantd, haved)
if self.state == "merged":
wantd = dict_merge(haved, wantd)
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
"""Select the appropriate function based on the state provided
:rtype: A list
:returns: the commands necessary to migrate the current configuration
to the desired configuration
"""
# convert list of dicts to dicts of dicts
wantd = {entry["name"]: entry for entry in self.want}
haved = {entry["name"]: entry for entry in self.have}
# turn all lists of dicts into dicts prior to merge
for entry in wantd, haved:
self._list_to_dict(entry)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
haved = {k: v for k, v in haved.items() if k in wantd or not wantd}
wantd = {}
# remove superfluous config
if self.state in ["overridden", "deleted"]:
for k, have in haved.items():
if k not in wantd:
self._compare(want={}, have=have)
for k, want in wantd.items():
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = self._ntp_list_to_dict(self.want)
haved = self._ntp_list_to_dict(self.have)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
haved = {
k: v
for k, v in iteritems(haved) if k in wantd or not wantd
}
wantd = {}
commandlist = self._commandlist(haved)
servernames = self._servernames(haved)
# removing the servername and commandlist from the list after deleting it from haved
for k, have in iteritems(haved):
if k not in wantd:
for hk, hval in iteritems(have):
if hk == "allow_clients" and hk in commandlist:
self.commands.append(
self._tmplt.render({"": hk},
"allow_clients_delete",
True))
commandlist.remove(hk)
elif hk == "listen_addresses" and hk in commandlist:
self.commands.append(
self._tmplt.render({"": hk},
"listen_addresses_delete",
True))
commandlist.remove(hk)
elif hk == "server" and have["server"] in servernames:
self._compareoverride(want={}, have=have)
servernames.remove(have["server"])
# remove existing config for overridden,replaced and deleted
# Getting the list of the server names from haved
# to avoid the duplication of overridding/replacing the servers
if self.state in ["overridden", "replaced"]:
commandlist = self._commandlist(haved)
servernames = self._servernames(haved)
for k, have in iteritems(haved):
if k not in wantd and "server" not in have:
self._compareoverride(want={}, have=have)
# removing the servername from the list after deleting it from haved
elif k not in wantd and have["server"] in servernames:
self._compareoverride(want={}, have=have)
servernames.remove(have["server"])
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
for entry in self.want, self.have:
self._bgp_list_to_dict(entry)
wantd = self.want
haved = self.have
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(self.have, self.want)
# if state is deleted, empty out wantd and set haved to elements to delete
if self.state == "deleted":
if wantd:
to_del = {
"neighbors": self._set_to_delete(haved, wantd),
"vrfs": {},
}
for k, hvrf in iteritems(haved.get("vrfs", {})):
wvrf = wantd.get("vrfs", {}).get(k, {})
to_del["vrfs"][k] = {
"neighbors": self._set_to_delete(hvrf, wvrf),
"vrf": k,
}
haved.update(to_del)
wantd = {"as_number": haved.get("as_number")}
self._compare(want=wantd, have=haved)
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
wantd = {entry["afi"]: entry for entry in self.want}
haved = {entry["afi"]: entry for entry in self.have}
self._prefix_list_to_dict(wantd)
self._prefix_list_to_dict(haved)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
haved = {
k: v
for k, v in iteritems(haved) if k in wantd or not wantd
}
wantd = {}
# remove superfluous config for overridden and deleted
if self.state in ["overridden", "deleted"]:
for k, have in iteritems(haved):
if k not in wantd:
self._compare(want={}, have=have)
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
# alligning cmd with negate cmd 1st followed by config cmd
if self.state in ["overridden", "replaced"]:
self.commands = [
each for each in self.commands if "no" in each
] + [each for each in self.commands if "no" not in each]
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
# convert list of dicts to dicts of dicts
wantd = {entry["name"]: entry for entry in self.want}
haved = {entry["name"]: entry for entry in self.have}
# turn all lists of dicts into dicts prior to merge
for entry in wantd, haved:
self._ospf_int_list_to_dict(entry)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
haved = {
k: v for k, v in iteritems(haved) if k in wantd or not wantd
}
for k, have in iteritems(haved):
self._compare(want={}, have=have)
wantd = {}
# remove superfluous config for overridden
if self.state == "overridden":
for k, have in iteritems(haved):
if k not in wantd:
self._compare(want={}, have=have)
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = {entry["afi"]: entry for entry in self.want}
haved = {entry["afi"]: entry for entry in self.have}
# Convert each of config list to dict
for each in wantd, haved:
self.list_to_dict(each)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
temp = None
for k, v in iteritems(haved):
if k in wantd:
if wantd[k].get("prefix_lists"):
want_afi_name = wantd[k].get("prefix_lists", {})
haved[k]["prefix_lists"] = {
key: val
for key, val in iteritems(v.get("prefix_lists"))
if key in want_afi_name
}
elif wantd:
temp = k
if temp:
haved.pop(k)
wantd = {}
for k, have in iteritems(haved):
for key, val in iteritems(have["prefix_lists"]):
if k == "ipv4":
k = "ip"
self.commands.append(
"no {0} prefix-list {1}".format(k, key),
)
# remove superfluous config for overridden and deleted
if self.state in ["overridden", "deleted"]:
for k, have in iteritems(haved):
want_afi = wantd.get(k, {})
for key, val in iteritems(have["prefix_lists"]):
if k == "ipv4":
k = "ip"
if want_afi and key not in want_afi.get("prefix_lists"):
self.commands.append(
"no {0} prefix-list {1}".format(k, key),
)
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
# alligning cmd with negate cmd 1st followed by config cmd
if self.state in ["overridden", "replaced"]:
self.commands = [each for each in self.commands if "no" in each] + [
each for each in self.commands if "no" not in each
]
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
if self.state in ["deleted", "replaced"]:
self._build_af_data()
for entry in self.want, self.have:
self._bgp_list_to_dict(entry)
# if state is deleted, clean up global params
if self.state == "deleted":
if not self.want or (self.have.get("as_number")
== self.want.get("as_number")):
self._compare(want={}, have=self.have)
elif self.state == "purged":
if not self.want or (self.have.get("as_number")
== self.want.get("as_number")):
self.addcmd(self.have or {}, "as_number", True)
else:
wantd = self.want
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(self.have, self.want)
self._compare(want=wantd, have=self.have)
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
wantd = {
entry["vrf"]: entry for entry in self.want.get("processes", [])
}
haved = {
entry["vrf"]: entry for entry in self.have.get("processes", [])
}
# turn all lists of dicts into dicts prior to merge
for entry in wantd, haved:
self._ospf_list_to_dict(entry)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
haved = {
k: v for k, v in iteritems(haved) if k in wantd or not wantd
}
wantd = {}
# remove superfluous config for overridden and deleted
if self.state in ["overridden", "deleted"]:
for k, have in iteritems(haved):
if k not in wantd and have.get("vrf") == k:
self.commands.append(self._tmplt.render(have, "vrf", True))
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
wantd = self._route_maps_list_to_dict(self.want)
haved = self._route_maps_list_to_dict(self.have)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
haved = {
k: v
for k, v in iteritems(haved) if k in wantd or not wantd
}
wantd = {}
# remove superfluous config for overridden and deleted
if self.state in ["overridden", "deleted"]:
for k, have in iteritems(haved):
if k not in wantd:
for _hk, hentry in iteritems(have.get("entries", {})):
self.commands.append(
self._tmplt.render(hentry, "route_map", True))
for wk, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(wk, {}))
def test_dict_merge():
base = dict(
obj2=dict(),
b1=True,
b2=False,
b3=False,
one=1,
two=2,
three=3,
obj1=dict(key1=1, key2=2),
l1=[1, 3],
l2=[1, 2, 3],
l4=[4],
nested=dict(n1=dict(n2=2)),
)
other = dict(
b1=True,
b2=False,
b3=True,
b4=True,
one=1,
three=4,
four=4,
obj1=dict(key1=2),
l1=[2, 1],
l2=[3, 2, 1],
l3=[1],
nested=dict(n1=dict(n2=2, n3=3)),
)
result = dict_merge(base, other)
# string assertions
assert "one" in result
assert "two" in result
assert result["three"] == 4
assert result["four"] == 4
# dict assertions
assert "obj1" in result
assert "key1" in result["obj1"]
assert "key2" in result["obj1"]
# list assertions
assert result["l1"] == [1, 2, 3]
assert "l2" in result
assert result["l3"] == [1]
assert "l4" in result
# nested assertions
assert "obj1" in result
assert result["obj1"]["key1"] == 2
assert "key2" in result["obj1"]
# bool assertions
assert "b1" in result
assert "b2" in result
assert result["b3"]
assert result["b4"]
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = {"snmp_server": self.want}
haved = {"snmp_server": self.have}
# turn all lists of dicts into dicts prior to merge
for entry in wantd["snmp_server"], haved["snmp_server"]:
self._snmp_server_list_to_dict(entry)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
haved = {
k: v
for k, v in iteritems(haved) if k in wantd or not wantd
}
wantd = {}
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
wantd = {}
for k, have in iteritems(haved):
self._compare(want={}, have=have)
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = self.list_to_dict(self.want)
haved = self.list_to_dict(self.have)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
haved = {
k: v for k, v in iteritems(haved) if k in wantd or not wantd
}
wantd = {}
# remove superfluous config for overridden and deleted
if self.state in ["overridden", "deleted"]:
for k, have in iteritems(haved):
if k not in wantd:
self._compare(wants={}, haveing=have)
for k, want in iteritems(wantd):
self._compare(wants=want, haveing=haved.pop(k, {}))
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = {entry["name"]: entry for entry in self.want}
haved = {entry["name"]: entry for entry in self.have}
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state in ["deleted", "purged"]:
haved = {
k: v
for k, v in iteritems(haved) if k in wantd or not wantd
}
wantd = {}
# remove superfluous config for overridden and deleted
if self.state in ["overridden", "deleted"]:
for k, have in iteritems(haved):
if k not in wantd:
self._compare(want={}, have=have)
if self.state == "purged":
for k, have in iteritems(haved):
self.purge(have)
else:
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def gen_config(self):
""" Select the appropriate function based on the state provided
:rtype: A list
:returns: the commands necessary to migrate the current configuration
to the desired configuration
"""
if self.want:
wantd = {(entry["object_type"]): entry for entry in self.want}
else:
wantd = {}
if self.have:
haved = {(entry["object_type"]): entry for entry in self.have}
else:
haved = {}
obj_gp = {}
for k, v in wantd.items():
temp = {}
for each in v.get("object_groups"):
temp[each.get("name")] = each
temp["object_type"] = k
obj_gp[k] = temp
if obj_gp:
wantd = obj_gp
obj_gp = {}
for k, v in haved.items():
temp = {}
for each in v.get("object_groups"):
temp[each.get("name")] = each
temp["object_type"] = k
obj_gp[k] = temp
if obj_gp:
haved = obj_gp
# if state is merged, merge want onto have
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, limit the have to anything in want
# set want to nothing
if self.state == "deleted":
haved = {
k: v
for k, v in iteritems(haved) if k in wantd or not wantd
}
wantd = {}
# delete processes first so we do run into "more than one" errors
if self.state in ["overridden", "deleted"]:
for k, have in iteritems(haved):
if k not in wantd:
for each_key, each_val in iteritems(have):
if each_key != "object_type":
each_val.update(
{"object_type": have.get("object_type")})
self.addcmd(each_val, "og_name", True)
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
wantd = deepcopy(self.want)
haved = deepcopy(self.have)
self._bgp_af_list_to_dict(wantd)
self._bgp_af_list_to_dict(haved)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
wantd = remove_empties(wantd)
haved = remove_empties(haved)
have_af = haved.get("address_family", {})
want_af = wantd.get("address_family", {})
wvrfs = wantd.get("vrfs", {})
hvrfs = haved.get("vrfs", {})
# if state is overridden or deleted, remove superfluos config
if self.state in ["deleted", "overridden"]:
if (haved and haved["as_number"]
== wantd.get("as_number")) or not wantd:
remove = True if self.state == "deleted" else False
purge = True if not wantd else False
self._remove_af(want_af, have_af, remove=remove, purge=purge)
for k, hvrf in iteritems(hvrfs):
wvrf = wvrfs.get(k, {})
self._remove_af(wvrf,
hvrf,
vrf=k,
remove=remove,
purge=purge)
if self.state in ["merged", "replaced", "overridden", "rendered"]:
for k, want in iteritems(want_af):
self._compare(want=want, have=have_af.pop(k, {}))
# handle vrf->af
for wk, wvrf in iteritems(wvrfs):
cur_ptr = len(self.commands)
hvrf = hvrfs.pop(wk, {})
for k, want in iteritems(wvrf):
self._compare(want=want, have=hvrf.pop(k, {}))
# add VRF command at correct position once
if cur_ptr != len(self.commands):
self.commands.insert(cur_ptr, "vrf {0}".format(wk))
if self.commands:
self.commands.insert(
0, "router bgp {as_number}".format(**haved or wantd))
def parse(self):
"""parse"""
result = {}
shared = {}
for line in self._lines:
for parser in self._tmplt.PARSERS:
cap = re.match(parser["getval"], line)
if cap:
capdict = cap.groupdict()
capdict = dict(
(k, v) for k, v in capdict.items() if v is not None)
if parser.get("shared"):
shared = capdict
vals = dict_merge(capdict, shared)
res = self._deepformat(deepcopy(parser["result"]), vals)
result = dict_merge(result, res)
break
return result
def test_dict_merge():
base = dict(obj2=dict(),
b1=True,
b2=False,
b3=False,
one=1,
two=2,
three=3,
obj1=dict(key1=1, key2=2),
l1=[1, 3],
l2=[1, 2, 3],
l4=[4],
nested=dict(n1=dict(n2=2)))
other = dict(b1=True,
b2=False,
b3=True,
b4=True,
one=1,
three=4,
four=4,
obj1=dict(key1=2),
l1=[2, 1],
l2=[3, 2, 1],
l3=[1],
nested=dict(n1=dict(n2=2, n3=3)))
result = dict_merge(base, other)
# string assertions
assert 'one' in result
assert 'two' in result
assert result['three'] == 4
assert result['four'] == 4
# dict assertions
assert 'obj1' in result
assert 'key1' in result['obj1']
assert 'key2' in result['obj1']
# list assertions
assert result['l1'] == [1, 2, 3]
assert 'l2' in result
assert result['l3'] == [1]
assert 'l4' in result
# nested assertions
assert 'obj1' in result
assert result['obj1']['key1'] == 2
assert 'key2' in result['obj1']
# bool assertions
assert 'b1' in result
assert 'b2' in result
assert result['b3']
assert result['b4']
def parse(self, net_template_obj):
""" Overrided network template parse
"""
result = {}
shared = {}
temp_pid = None
for line in net_template_obj._lines:
for parser in net_template_obj._tmplt.PARSERS:
cap = re.match(parser["getval"], line)
if cap:
capdict = cap.groupdict()
temp = {}
for k, v in iteritems(capdict):
if v is not None:
temp.update({k: v})
capdict = temp
if "address-family" in line:
capdict.update({"id": temp_pid})
if (
"manet" in line
and "pid" not in shared
and shared.get("unicast")
):
del shared["unicast"]
if "router ospfv3" in line:
temp_pid = None
if parser.get("shared"):
shared = capdict
if not temp_pid and (
shared.get("pid") or shared.get("id")
):
temp_pid = shared.get("pid") or shared.get("id")
vals = utils.dict_merge(capdict, shared)
try:
res = net_template_obj._deepformat(
deepcopy(parser["result"]), vals
)
except Exception:
continue
result = utils.dict_merge(result, res)
break
return result
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
if self.want:
wantd = {}
for each in self.want:
wantd.update({each["name"]: each})
else:
wantd = {}
if self.have:
haved = {}
for each in self.have:
haved.update({each["name"]: each})
else:
haved = {}
for each in wantd, haved:
self.list_to_dict(each)
if self.state == "merged":
wantd = dict_merge(haved, wantd)
if self.state == "deleted":
temp = {}
for k, v in iteritems(haved):
if k in wantd or not wantd:
temp.update({k: v})
haved = temp
wantd = {}
if self.state in ["overridden", "deleted"]:
for k, have in iteritems(haved):
if k not in wantd and (have.get("ipv4") or have.get("ipv6")):
self.addcmd(have, "name", False)
self.delete_l3_attributes(have)
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
if self.state == "overridden" or self.state == "replaced":
temp = []
temp_cmd = []
for each in self.commands:
if "interface" in each:
if temp_cmd:
temp.extend(sorted(temp_cmd)[::-1])
temp_cmd = []
temp.append(each)
if "interface" not in each:
temp_cmd.append(each)
if temp_cmd:
temp.extend(sorted(temp_cmd)[::-1])
self.commands = temp
def generate_commands(self):
""" Generate configuration commands to send based on
want, have and desired state.
"""
if self.want:
wantd = {self.want["as_number"]: self.want}
else:
wantd = {}
if self.have:
haved = {self.have["as_number"]: self.have}
else:
haved = {}
wantd, haved = self.list_to_dict(wantd, haved)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted" and self.have:
if (
not self.want
or self.have.get("as_number") == self.want.get("as_number")
and len(self.have) > 1
):
self.addcmd(
{"as_number": haved[list(haved)[0]].pop("as_number")},
"as_number",
False,
)
self.compare(
parsers=self.parsers, want={}, have=haved[list(haved)[0]]
)
self._compare(want={}, have=haved[list(haved)[0]])
self._list_params_compare(want={}, have=haved[list(haved)[0]])
wantd = {}
if self.state == "purged" and self.have:
if (
not self.want
or (self.have.get("as_number") == self.want.get("as_number"))
and len(self.have) >= 1
):
self.addcmd(
{"as_number": haved[list(haved)[0]].pop("as_number")},
"as_number",
True,
)
wantd = {}
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = self._logging_list_to_dict(self.want)
haved = self._logging_list_to_dict(self.have)
if self.state == "deleted":
# empty out want (in case something was specified)
# some items are populated later on for correct removal
wantd = {}
# pre-process `event.x.y` keys
for x in self.parsers[4:7]:
have_k = get_from_dict(haved, x)
want_k = get_from_dict(wantd, x)
if have_k is None and want_k is not None:
# set have to True to mimic default state
# this allows negate commands to be issued
self.__update_dict(haved, x)
if all((
self.state in self._state_set,
have_k is False,
want_k is None,
), ):
# if want is missing and have is negated
# set want to True in order to revert to default state
self.__update_dict(wantd, x)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
for x in self.parsers[0:4]:
hstate = haved.get(x, {}).get("state", "")
wstate = wantd.get(x, {}).get("state", "")
if hstate == "disabled" and not wstate:
# this ensures that updates are done
# with correct `state`
if wantd.get(x, {}):
wantd[x].update({"state": "enabled"})
wantd = dict_merge(haved, wantd)
if self.state in self._state_set:
# set default states for keys that appear in negated form
for x in self.parsers[0:3]:
if x in haved and x not in wantd:
wantd[x] = {"state": "enabled"}
if "rate_limit" in haved and "rate_limit" not in wantd:
wantd["rate_limit"] = "enabled"
if "logfile" in haved and "logfile" not in wantd:
wantd["logfile"] = {"name": "messages", "severity": 5}
self._compare(want=wantd, have=haved)
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = self._ntp_list_to_dict(self.want)
haved = self._ntp_list_to_dict(self.have)
if self.state == "merged":
wantd = dict_merge(haved, wantd)
if self.state == "deleted":
wantd = {}
self._compare(want=wantd, have=haved)
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = self._list_to_dict(self.want)
haved = self._list_to_dict(self.have)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# this ensures that if user sets `enable: True` for a trap
# all suboptions for that trap are set to True
for x in [
"traps.aaa",
"traps.bridge",
"traps.callhome",
"traps.cfs",
"traps.config",
"traps.entity",
"traps.feature_control",
"traps.generic",
"traps.license",
"traps.link",
"traps.mmode",
"traps.rf",
"traps.rmon",
"traps.snmp",
"traps.storm_control",
"traps.stpx",
"traps.syslog",
"traps.sysmgr",
"traps.system",
"traps.upgrade",
"traps.vtp",
]:
entry = get_from_dict(wantd, x)
if entry and entry.get("enable", False):
key = x.split(".")
wantd[key[0]][key[1]].pop("enable")
for i in self.parsers:
if i.startswith(x):
key = i.split(".")
wantd[key[0]][key[1]][key[2]] = True
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
wantd = {}
self._compare(want=wantd, have=haved)
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = {}
haved = {}
for entry in self.want:
wantd.update({entry["name"]: entry})
for entry in self.have:
haved.update({entry["name"]: entry})
# turn all lists of dicts into dicts prior to merge
for entry in wantd, haved:
self._ospf_int_list_to_dict(entry)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
h_del = {}
for k, v in iteritems(haved):
if k in wantd or not wantd:
h_del.update({k: v})
haved = h_del
have_int = []
for k, have in iteritems(haved):
if k in wantd:
have_int.append(k)
self._remove_ospf_int(have)
wantd = {}
if self.state == "overridden":
have_int = []
for k, have in iteritems(haved):
if k not in wantd:
have_int.append(k)
self._remove_ospf_int(have)
# remove superfluous config for overridden and deleted
if self.state in ["overridden", "deleted"]:
# removing the interfaces from haved that are already negated
for interface in have_int:
haved.pop(interface)
for k, have in iteritems(haved):
if k not in wantd:
self._compare(want={}, have=have)
for k, want in iteritems(wantd):
self._compare(want=want, have=haved.pop(k, {}))
def compare_arrays(old_params, new_params, param_name):
old = old_params.get(param_name) or []
new = new_params.get(param_name) or []
oldd = {}
for item in old:
name = item['name']
oldd[name] = item
newd = {}
for item in new:
name = item['name']
newd[name] = item
newd = dict_merge(oldd, newd)
return newd == oldd
def generate_commands(self):
"""Generate configuration commands to send based on
want, have and desired state.
"""
wantd = self._snmp_list_to_dict(self.want)
haved = self._snmp_list_to_dict(self.have)
# if state is merged, merge want onto have and then compare
if self.state == "merged":
wantd = dict_merge(haved, wantd)
# if state is deleted, empty out wantd and set haved to wantd
if self.state == "deleted":
wantd = {}
self._compare(want=wantd, have=haved)
