def test_default_generation(self, mock_get_devicelist,
mock_sys_netdev_info,
mock_sys_dev_path):
tmp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
_setup_test(tmp_dir, mock_get_devicelist,
mock_sys_netdev_info, mock_sys_dev_path)
network_cfg = net.generate_fallback_config()
ns = network_state.parse_net_config_data(network_cfg,
skip_broken=False)
render_dir = os.path.join(tmp_dir, "render")
os.makedirs(render_dir)
renderer = sysconfig.Renderer()
renderer.render_network_state(render_dir, ns)
render_file = 'etc/sysconfig/network-scripts/ifcfg-eth1000'
with open(os.path.join(render_dir, render_file)) as fh:
content = fh.read()
expected_content = """
# Created by cloud-init on instance boot automatically, do not edit.
#
BOOTPROTO=dhcp
DEVICE=eth1000
HWADDR=07-1C-C6-75-A4-BE
NM_CONTROLLED=no
ONBOOT=yes
TYPE=Ethernet
USERCTL=no
""".lstrip()
self.assertEqual(expected_content, content)
def _render_and_read(self,
network_config=None,
state=None,
eni_path=None,
links_prefix=None,
netrules_path=None):
if network_config:
ns = network_state.parse_net_config_data(network_config)
elif state:
ns = state
else:
raise ValueError("Expected data or state, got neither")
if eni_path is None:
eni_path = 'etc/network/interfaces'
renderer = eni.Renderer(
config={
'eni_path': eni_path,
'links_path_prefix': links_prefix,
'netrules_path': netrules_path
})
renderer.render_network_state(self.tmp_dir, ns)
return dir2dict(self.tmp_dir)
def test_bring_up_all_interfaces_v2(self, m_subp, activator,
available_calls, expected_call_list,
available_mocks):
network_state = parse_net_config_data(load(V2_CONFIG))
activator.bring_up_all_interfaces(network_state)
for call in m_subp.call_args_list:
assert call in expected_call_list
def test_default_generation(self, mock_get_devicelist,
mock_sys_netdev_info,
mock_sys_dev_path):
tmp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
_setup_test(tmp_dir, mock_get_devicelist,
mock_sys_netdev_info, mock_sys_dev_path)
network_cfg = net.generate_fallback_config()
ns = network_state.parse_net_config_data(network_cfg,
skip_broken=False)
render_dir = os.path.join(tmp_dir, "render")
os.makedirs(render_dir)
renderer = eni.Renderer(
{'links_path_prefix': None,
'eni_path': 'interfaces', 'netrules_path': None,
})
renderer.render_network_state(render_dir, ns)
self.assertTrue(os.path.exists(os.path.join(render_dir,
'interfaces')))
with open(os.path.join(render_dir, 'interfaces')) as fh:
contents = fh.read()
expected = """
auto lo
iface lo inet loopback
auto eth1000
iface eth1000 inet dhcp
"""
self.assertEqual(expected.lstrip(), contents.lstrip())
def test_default_generation(self, mock_get_devicelist,
mock_read_sys_net,
mock_sys_dev_path):
tmp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
_setup_test(tmp_dir, mock_get_devicelist,
mock_read_sys_net, mock_sys_dev_path)
network_cfg = net.generate_fallback_config()
ns = network_state.parse_net_config_data(network_cfg,
skip_broken=False)
render_dir = os.path.join(tmp_dir, "render")
os.makedirs(render_dir)
renderer = eni.Renderer(
{'links_path_prefix': None,
'eni_path': 'interfaces', 'netrules_path': None,
})
renderer.render_network_state(render_dir, ns)
self.assertTrue(os.path.exists(os.path.join(render_dir,
'interfaces')))
with open(os.path.join(render_dir, 'interfaces')) as fh:
contents = fh.read()
expected = """
auto lo
iface lo inet loopback
auto eth1000
iface eth1000 inet dhcp
"""
self.assertEqual(expected.lstrip(), contents.lstrip())
def test_default_generation(self, mock_get_devicelist,
mock_read_sys_net,
mock_sys_dev_path):
tmp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
_setup_test(tmp_dir, mock_get_devicelist,
mock_read_sys_net, mock_sys_dev_path)
network_cfg = net.generate_fallback_config()
ns = network_state.parse_net_config_data(network_cfg,
skip_broken=False)
render_dir = os.path.join(tmp_dir, "render")
os.makedirs(render_dir)
renderer = sysconfig.Renderer()
renderer.render_network_state(render_dir, ns)
render_file = 'etc/sysconfig/network-scripts/ifcfg-eth1000'
with open(os.path.join(render_dir, render_file)) as fh:
content = fh.read()
expected_content = """
# Created by cloud-init on instance boot automatically, do not edit.
#
BOOTPROTO=dhcp
DEVICE=eth1000
HWADDR=07-1C-C6-75-A4-BE
NM_CONTROLLED=no
ONBOOT=yes
TYPE=Ethernet
USERCTL=no
""".lstrip()
self.assertEqual(expected_content, content)
def test_with_header(self):
header = "# hello world\n"
rendered = eni.network_state_to_eni(
network_state=network_state.parse_net_config_data(self.mycfg),
header=header, render_hwaddress=True)
self.assertIn(header, rendered)
self.assertIn(self.my_mac, rendered)
def apply_network_config(self, netconfig, bring_up=False) -> bool:
"""Apply the network config.
If bring_up is True, attempt to bring up the passed in devices. If
devices is None, attempt to bring up devices returned by
_write_network_config.
Returns True if any devices failed to come up, otherwise False.
"""
# This method is preferred to apply_network which only takes
# a much less complete network config format (interfaces(5)).
network_state = parse_net_config_data(netconfig)
try:
self._write_network_state(network_state)
except NotImplementedError:
# backwards compat until all distros have apply_network_config
return self._apply_network_from_network_config(
netconfig, bring_up=bring_up
)
# Now try to bring them up
if bring_up:
LOG.debug("Bringing up newly configured network interfaces")
try:
network_activator = activators.select_activator()
except activators.NoActivatorException:
LOG.warning(
"No network activator found, not bringing up "
"network interfaces"
)
return True
network_activator.bring_up_all_interfaces(network_state)
else:
LOG.debug("Not bringing up newly configured network interfaces")
return False
def test_bond_conversion(self):
# light testing of bond conversion and eni rendering of bond
ncfg = openstack.convert_net_json(NETWORK_DATA_BOND,
known_macs=KNOWN_MACS)
eni_renderer = eni.Renderer()
eni_renderer.render_network_state(
network_state.parse_net_config_data(ncfg), target=self.tmp)
with open(os.path.join(self.tmp, "etc",
"network", "interfaces"), 'r') as f:
eni_rendering = f.read()
# Verify there are expected interfaces in the net config.
interfaces = sorted(
[i['name'] for i in ncfg['config']
if i['type'] in ('vlan', 'bond', 'physical')])
self.assertEqual(
sorted(["oeth0", "oeth1", "bond0", "bond0.602", "bond0.612"]),
interfaces)
words = eni_rendering.split()
# 'eth0' and 'eth1' are the ids. because their mac adresses
# map to other names, we should not see them in the ENI
self.assertNotIn('eth0', words)
self.assertNotIn('eth1', words)
# oeth0 and oeth1 are the interface names for eni.
# bond0 will be generated for the bond. Each should be auto.
self.assertIn("auto oeth0", eni_rendering)
self.assertIn("auto oeth1", eni_rendering)
self.assertIn("auto bond0", eni_rendering)
# The bond should have the given mac address
pos = eni_rendering.find("auto bond0")
self.assertIn(BOND_MAC, eni_rendering[pos:])
def test_bond_conversion(self):
# light testing of bond conversion and eni rendering of bond
ncfg = openstack.convert_net_json(NETWORK_DATA_BOND,
known_macs=KNOWN_MACS)
eni_renderer = eni.Renderer()
eni_renderer.render_network_state(
self.tmp, network_state.parse_net_config_data(ncfg))
with open(os.path.join(self.tmp, "etc",
"network", "interfaces"), 'r') as f:
eni_rendering = f.read()
# Verify there are expected interfaces in the net config.
interfaces = sorted(
[i['name'] for i in ncfg['config']
if i['type'] in ('vlan', 'bond', 'physical')])
self.assertEqual(
sorted(["oeth0", "oeth1", "bond0", "bond0.602", "bond0.612"]),
interfaces)
words = eni_rendering.split()
# 'eth0' and 'eth1' are the ids. because their mac adresses
# map to other names, we should not see them in the ENI
self.assertNotIn('eth0', words)
self.assertNotIn('eth1', words)
# oeth0 and oeth1 are the interface names for eni.
# bond0 will be generated for the bond. Each should be auto.
self.assertIn("auto oeth0", eni_rendering)
self.assertIn("auto oeth1", eni_rendering)
self.assertIn("auto bond0", eni_rendering)
def test_with_header(self):
header = "# hello world\n"
rendered = eni.network_state_to_eni(
network_state=network_state.parse_net_config_data(self.mycfg),
header=header, render_hwaddress=True)
self.assertIn(header, rendered)
self.assertIn(self.my_mac, rendered)
def render_network_config(self,
network_config,
templates=None,
target=None):
return self.render_network_state(
network_state=parse_net_config_data(network_config),
templates=templates,
target=target)
def device_detected(self) -> bool:
netstate = parse_net_config_data(self.config)
found = [
iface for iface in netstate.iter_interfaces()
if iface.get("mac_address") == self.id
]
LOG.debug("Ifaces with ID=%s : %s", self.id, found)
return len(found) > 0
def _apply_network_from_network_config(self, netconfig, bring_up=True):
distro = self.__class__
LOG.warn("apply_network_config is not currently implemented "
"for distribution '%s'. Attempting to use apply_network",
distro)
header = '\n'.join([
"# Converted from network_config for distro %s" % distro,
"# Implmentation of _write_network_config is needed."
])
ns = network_state.parse_net_config_data(netconfig)
contents = eni.network_state_to_eni(
ns, header=header, render_hwaddress=True)
return self.apply_network(contents, bring_up=bring_up)
def _apply_network_from_network_config(self, netconfig, bring_up=True):
distro = self.__class__
LOG.warn("apply_network_config is not currently implemented "
"for distribution '%s'. Attempting to use apply_network",
distro)
header = '\n'.join([
"# Converted from network_config for distro %s" % distro,
"# Implmentation of _write_network_config is needed."
])
ns = network_state.parse_net_config_data(netconfig)
contents = eni.network_state_to_eni(
ns, header=header, render_hwaddress=True)
return self.apply_network(contents, bring_up=bring_up)
def test_config_with_explicit_loopback(self):
tmp_dir = self.tmp_dir()
ns = network_state.parse_net_config_data(CONFIG_V1_EXPLICIT_LOOPBACK)
renderer = eni.Renderer()
renderer.render_network_state(ns, tmp_dir)
expected = """\
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet dhcp
"""
self.assertEqual(expected,
dir2dict(tmp_dir)['/etc/network/interfaces'])
def test_openstack_rendering_samples(self):
for os_sample in OS_SAMPLES:
render_dir = self.tmp_dir()
ex_input = os_sample['in_data']
ex_mac_addrs = os_sample['in_macs']
network_cfg = openstack.convert_net_json(ex_input,
known_macs=ex_mac_addrs)
ns = network_state.parse_net_config_data(network_cfg,
skip_broken=False)
renderer = sysconfig.Renderer()
renderer.render_network_state(ns, render_dir)
for fn, expected_content in os_sample.get('out_sysconfig', []):
with open(os.path.join(render_dir, fn)) as fh:
self.assertEqual(expected_content, fh.read())
def test_vlan(self):
# light testing of vlan config conversion and eni rendering
ncfg = openstack.convert_net_json(NETWORK_DATA_VLAN,
known_macs=KNOWN_MACS)
eni_renderer = eni.Renderer()
eni_renderer.render_network_state(
self.tmp, network_state.parse_net_config_data(ncfg))
with open(os.path.join(self.tmp, "etc",
"network", "interfaces"), 'r') as f:
eni_rendering = f.read()
self.assertIn("iface enp0s1", eni_rendering)
self.assertIn("address 10.0.1.5", eni_rendering)
self.assertIn("auto enp0s1.602", eni_rendering)
def test_vlan(self):
# light testing of vlan config conversion and eni rendering
ncfg = openstack.convert_net_json(NETWORK_DATA_VLAN,
known_macs=KNOWN_MACS)
eni_renderer = eni.Renderer()
eni_renderer.render_network_state(
network_state.parse_net_config_data(ncfg), target=self.tmp)
with open(os.path.join(self.tmp, "etc",
"network", "interfaces"), 'r') as f:
eni_rendering = f.read()
self.assertIn("iface enp0s1", eni_rendering)
self.assertIn("address 10.0.1.5", eni_rendering)
self.assertIn("auto enp0s1.602", eni_rendering)
def test_openstack_rendering_samples(self):
tmp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
render_dir = os.path.join(tmp_dir, "render")
for os_sample in OS_SAMPLES:
ex_input = os_sample['in_data']
ex_mac_addrs = os_sample['in_macs']
network_cfg = openstack.convert_net_json(
ex_input, known_macs=ex_mac_addrs)
ns = network_state.parse_net_config_data(network_cfg,
skip_broken=False)
renderer = sysconfig.Renderer()
renderer.render_network_state(render_dir, ns)
for fn, expected_content in os_sample.get('out_sysconfig', []):
with open(os.path.join(render_dir, fn)) as fh:
self.assertEqual(expected_content, fh.read())
def test_netplan_render_calls_postcmds(self, mock_netplan_generate,
mock_net_setup_link):
tmp_dir = self.tmp_dir()
ns = network_state.parse_net_config_data(self.mycfg, skip_broken=False)
render_dir = os.path.join(tmp_dir, "render")
os.makedirs(render_dir)
render_target = 'netplan.yaml'
renderer = netplan.Renderer({
'netplan_path': render_target,
'postcmds': True
})
renderer.render_network_state(render_dir, ns)
mock_netplan_generate.assert_called_with(run=True)
mock_net_setup_link.assert_called_with(run=True)
def _apply_network_from_network_config(self, netconfig, bring_up=True):
"""Deprecated. Remove if/when arch and gentoo support renderers."""
distro = self.__class__
LOG.warning(
"apply_network_config is not currently implemented "
"for distribution '%s'. Attempting to use apply_network",
distro,
)
header = "\n".join([
"# Converted from network_config for distro %s" % distro,
"# Implementation of _write_network_config is needed.",
])
ns = network_state.parse_net_config_data(netconfig)
contents = eni.network_state_to_eni(ns,
header=header,
render_hwaddress=True)
return self.apply_network(contents, bring_up=bring_up)
def apply_network_config(self, netconfig, bring_up=False):
# apply network config netconfig
# This method is preferred to apply_network which only takes
# a much less complete network config format (interfaces(5)).
network_state = parse_net_config_data(netconfig)
try:
self._write_network_state(network_state)
except NotImplementedError:
# backwards compat until all distros have apply_network_config
return self._apply_network_from_network_config(
netconfig, bring_up=bring_up)
# Now try to bring them up
if bring_up:
network_activator = activators.select_activator()
network_activator.bring_up_all_interfaces(network_state)
return False
def _render_and_read(self, network_config=None, state=None, eni_path=None,
links_prefix=None, netrules_path=None):
if network_config:
ns = network_state.parse_net_config_data(network_config)
elif state:
ns = state
else:
raise ValueError("Expected data or state, got neither")
if eni_path is None:
eni_path = 'etc/network/interfaces'
renderer = eni.Renderer(
config={'eni_path': eni_path, 'links_path_prefix': links_prefix,
'netrules_path': netrules_path})
renderer.render_network_state(self.tmp_dir, ns)
return dir2dict(self.tmp_dir)
def test_conversion_with_route(self):
ncfg = openstack.convert_net_json(NETWORK_DATA_2,
known_macs=KNOWN_MACS)
# not the best test, but see that we get a route in the
# network config and that it gets rendered to an ENI file
routes = []
for n in ncfg['config']:
for s in n.get('subnets', []):
routes.extend(s.get('routes', []))
self.assertIn(
{'network': '0.0.0.0', 'netmask': '0.0.0.0', 'gateway': '2.2.2.9'},
routes)
eni_renderer = eni.Renderer()
eni_renderer.render_network_state(
self.tmp, network_state.parse_net_config_data(ncfg))
with open(os.path.join(self.tmp, "etc",
"network", "interfaces"), 'r') as f:
eni_rendering = f.read()
self.assertIn("route add default gw 2.2.2.9", eni_rendering)
def test_conversion_with_route(self):
ncfg = openstack.convert_net_json(NETWORK_DATA_2,
known_macs=KNOWN_MACS)
# not the best test, but see that we get a route in the
# network config and that it gets rendered to an ENI file
routes = []
for n in ncfg['config']:
for s in n.get('subnets', []):
routes.extend(s.get('routes', []))
self.assertIn(
{'network': '0.0.0.0', 'netmask': '0.0.0.0', 'gateway': '2.2.2.9'},
routes)
eni_renderer = eni.Renderer()
eni_renderer.render_network_state(
network_state.parse_net_config_data(ncfg), target=self.tmp)
with open(os.path.join(self.tmp, "etc",
"network", "interfaces"), 'r') as f:
eni_rendering = f.read()
self.assertIn("route add default gw 2.2.2.9", eni_rendering)
def test_config_with_explicit_loopback(self):
ns = network_state.parse_net_config_data(CONFIG_V1_EXPLICIT_LOOPBACK)
render_dir = self.tmp_path("render")
os.makedirs(render_dir)
renderer = sysconfig.Renderer()
renderer.render_network_state(ns, render_dir)
found = dir2dict(render_dir)
nspath = '/etc/sysconfig/network-scripts/'
self.assertNotIn(nspath + 'ifcfg-lo', found.keys())
expected = """\
# Created by cloud-init on instance boot automatically, do not edit.
#
BOOTPROTO=dhcp
DEVICE=eth0
NM_CONTROLLED=no
ONBOOT=yes
TYPE=Ethernet
USERCTL=no
"""
self.assertEqual(expected, found[nspath + 'ifcfg-eth0'])
def _render_and_read(self,
network_config=None,
state=None,
netplan_path=None,
dir=None):
if dir is None:
dir = self.tmp_dir()
if network_config:
ns = network_state.parse_net_config_data(network_config)
elif state:
ns = state
else:
raise ValueError("Expected data or state, got neither")
if netplan_path is None:
netplan_path = 'etc/netplan/50-cloud-init.yaml'
renderer = netplan.Renderer(config={'netplan_path': netplan_path})
renderer.render_network_state(dir, ns)
return dir2dict(dir)
def test_default_generation(self, mock_get_devicelist, mock_read_sys_net,
mock_sys_dev_path):
tmp_dir = self.tmp_dir()
_setup_test(tmp_dir, mock_get_devicelist, mock_read_sys_net,
mock_sys_dev_path)
network_cfg = net.generate_fallback_config()
ns = network_state.parse_net_config_data(network_cfg,
skip_broken=False)
render_dir = os.path.join(tmp_dir, "render")
os.makedirs(render_dir)
render_target = 'netplan.yaml'
renderer = netplan.Renderer({
'netplan_path': render_target,
'postcmds': False
})
renderer.render_network_state(render_dir, ns)
self.assertTrue(os.path.exists(os.path.join(render_dir,
render_target)))
with open(os.path.join(render_dir, render_target)) as fh:
contents = fh.read()
print(contents)
expected = """
network:
version: 2
ethernets:
eth1000:
dhcp4: true
match:
macaddress: 07-1c-c6-75-a4-be
set-name: eth1000
"""
self.assertEqual(expected.lstrip(), contents.lstrip())
def test_netplan_postcmds(self, mock_subp, mock_devlist):
mock_devlist.side_effect = [['lo']]
tmp_dir = self.tmp_dir()
ns = network_state.parse_net_config_data(self.mycfg, skip_broken=False)
render_dir = os.path.join(tmp_dir, "render")
os.makedirs(render_dir)
render_target = 'netplan.yaml'
renderer = netplan.Renderer({
'netplan_path': render_target,
'postcmds': True
})
renderer.render_network_state(render_dir, ns)
expected = [
mock.call(['netplan', 'generate'], capture=True),
mock.call([
'udevadm', 'test-builtin', 'net_setup_link',
'/sys/class/net/lo'
],
capture=True),
]
mock_subp.assert_has_calls(expected)
def _write_network_config(self, netconfig):
ns = parse_net_config_data(netconfig)
self._net_renderer.render_network_state("/", ns)
_maybe_remove_legacy_eth0()
return []
def handle_args(name, args):
if not args.directory.endswith("/"):
args.directory += "/"
if not os.path.isdir(args.directory):
os.makedirs(args.directory)
if args.debug:
log.setupBasicLogging(level=log.DEBUG)
else:
log.setupBasicLogging(level=log.WARN)
if args.mac:
known_macs = {}
for item in args.mac:
iface_name, iface_mac = item.split(",", 1)
known_macs[iface_mac] = iface_name
else:
known_macs = None
net_data = args.network_data.read()
if args.kind == "eni":
pre_ns = eni.convert_eni_data(net_data)
elif args.kind == "yaml":
pre_ns = safeyaml.load(net_data)
if 'network' in pre_ns:
pre_ns = pre_ns.get('network')
if args.debug:
sys.stderr.write('\n'.join(
["Input YAML", safeyaml.dumps(pre_ns), ""]))
elif args.kind == 'network_data.json':
pre_ns = openstack.convert_net_json(
json.loads(net_data), known_macs=known_macs)
elif args.kind == 'azure-imds':
pre_ns = azure.parse_network_config(json.loads(net_data))
elif args.kind == 'vmware-imc':
config = ovf.Config(ovf.ConfigFile(args.network_data.name))
pre_ns = ovf.get_network_config_from_conf(config, False)
ns = network_state.parse_net_config_data(pre_ns)
if args.debug:
sys.stderr.write('\n'.join(
["", "Internal State", safeyaml.dumps(ns), ""]))
distro_cls = distros.fetch(args.distro)
distro = distro_cls(args.distro, {}, None)
config = {}
if args.output_kind == "eni":
r_cls = eni.Renderer
config = distro.renderer_configs.get('eni')
elif args.output_kind == "netplan":
r_cls = netplan.Renderer
config = distro.renderer_configs.get('netplan')
# don't run netplan generate/apply
config['postcmds'] = False
# trim leading slash
config['netplan_path'] = config['netplan_path'][1:]
# enable some netplan features
config['features'] = ['dhcp-use-domains', 'ipv6-mtu']
elif args.output_kind == "networkd":
r_cls = networkd.Renderer
config = distro.renderer_configs.get('networkd')
elif args.output_kind == "sysconfig":
r_cls = sysconfig.Renderer
config = distro.renderer_configs.get('sysconfig')
else:
raise RuntimeError("Invalid output_kind")
r = r_cls(config=config)
sys.stderr.write(''.join([
"Read input format '%s' from '%s'.\n" % (
args.kind, args.network_data.name),
"Wrote output format '%s' to '%s'\n" % (
args.output_kind, args.directory)]) + "\n")
r.render_network_state(network_state=ns, target=args.directory)
def _write_network_config(self, netconfig):
ns = parse_net_config_data(netconfig)
self._net_renderer.render_network_state("/", ns)
return []
def handle_args(name, args):
if not args.directory.endswith("/"):
args.directory += "/"
if not os.path.isdir(args.directory):
os.makedirs(args.directory)
if args.debug:
log.setupBasicLogging(level=log.DEBUG)
else:
log.setupBasicLogging(level=log.WARN)
if args.mac:
known_macs = {}
for item in args.mac:
iface_name, iface_mac = item.split(",", 1)
known_macs[iface_mac] = iface_name
else:
known_macs = None
net_data = args.network_data.read()
if args.kind == "eni":
pre_ns = eni.convert_eni_data(net_data)
elif args.kind == "yaml":
pre_ns = yaml.load(net_data)
if 'network' in pre_ns:
pre_ns = pre_ns.get('network')
if args.debug:
sys.stderr.write('\n'.join(
["Input YAML",
yaml.dump(pre_ns, default_flow_style=False, indent=4), ""]))
elif args.kind == 'network_data.json':
pre_ns = openstack.convert_net_json(
json.loads(net_data), known_macs=known_macs)
elif args.kind == 'azure-imds':
pre_ns = azure.parse_network_config(json.loads(net_data))
elif args.kind == 'vmware-imc':
config = ovf.Config(ovf.ConfigFile(args.network_data.name))
pre_ns = ovf.get_network_config_from_conf(config, False)
ns = network_state.parse_net_config_data(pre_ns)
if not ns:
raise RuntimeError("No valid network_state object created from"
"input data")
if args.debug:
sys.stderr.write('\n'.join([
"", "Internal State",
yaml.dump(ns, default_flow_style=False, indent=4), ""]))
distro_cls = distros.fetch(args.distro)
distro = distro_cls(args.distro, {}, None)
config = {}
if args.output_kind == "eni":
r_cls = eni.Renderer
config = distro.renderer_configs.get('eni')
elif args.output_kind == "netplan":
r_cls = netplan.Renderer
config = distro.renderer_configs.get('netplan')
# don't run netplan generate/apply
config['postcmds'] = False
# trim leading slash
config['netplan_path'] = config['netplan_path'][1:]
else:
r_cls = sysconfig.Renderer
config = distro.renderer_configs.get('sysconfig')
r = r_cls(config=config)
sys.stderr.write(''.join([
"Read input format '%s' from '%s'.\n" % (
args.kind, args.network_data.name),
"Wrote output format '%s' to '%s'\n" % (
args.output_kind, args.directory)]) + "\n")
r.render_network_state(network_state=ns, target=args.directory)
def test_valid_config_gets_network_state(self):
ncfg = {'version': 2, 'otherconfig': {}, 'somemore': [1, 2, 3]}
result = network_state.parse_net_config_data(ncfg)
self.assertNotEqual(None, result)
def test_empty_v2_config_gets_network_state(self):
ncfg = {'version': 2}
result = network_state.parse_net_config_data(ncfg)
self.assertNotEqual(None, result)
def test_unknown_versions_returns_none(self):
ncfg = {'version': 13.2}
self.assertEqual(None, network_state.parse_net_config_data(ncfg))
def test_version_2_passes_self_as_config(self):
ncfg = {'version': 2, 'otherconfig': {}, 'somemore': [1, 2, 3]}
network_state.parse_net_config_data(ncfg)
self.assertEqual([mock.call(version=2, config=ncfg)],
self.m_nsi.call_args_list)
def test_missing_version_returns_none(self):
ncfg = {}
self.assertEqual(None, network_state.parse_net_config_data(ncfg))
def _write_network_config(self, netconfig):
ns = parse_net_config_data(netconfig)
self._net_renderer.render_network_state("/", ns)
return []
def test_no_hwaddress(self):
rendered = eni.network_state_to_eni(
network_state=network_state.parse_net_config_data(self.mycfg),
render_hwaddress=False)
self.assertNotIn(self.my_mac, rendered)
self.assertNotIn("hwaddress", rendered)
def test_no_hwaddress(self):
rendered = eni.network_state_to_eni(
network_state=network_state.parse_net_config_data(self.mycfg),
render_hwaddress=False)
self.assertNotIn(self.my_mac, rendered)
self.assertNotIn("hwaddress", rendered)
def handle_args(name, args):
if not args.directory.endswith("/"):
args.directory += "/"
if not os.path.isdir(args.directory):
os.makedirs(args.directory)
if args.debug:
log.setupBasicLogging(level=log.DEBUG)
else:
log.setupBasicLogging(level=log.WARN)
if args.mac:
known_macs = {}
for item in args.mac:
iface_name, iface_mac = item.split(",", 1)
known_macs[iface_mac] = iface_name
else:
known_macs = None
net_data = args.network_data.read()
if args.kind == "eni":
pre_ns = eni.convert_eni_data(net_data)
ns = network_state.parse_net_config_data(pre_ns)
elif args.kind == "yaml":
pre_ns = yaml.load(net_data)
if 'network' in pre_ns:
pre_ns = pre_ns.get('network')
if args.debug:
sys.stderr.write('\n'.join(
["Input YAML",
yaml.dump(pre_ns, default_flow_style=False, indent=4), ""]))
ns = network_state.parse_net_config_data(pre_ns)
elif args.kind == 'network_data.json':
pre_ns = openstack.convert_net_json(
json.loads(net_data), known_macs=known_macs)
ns = network_state.parse_net_config_data(pre_ns)
elif args.kind == 'azure-imds':
pre_ns = azure.parse_network_config(json.loads(net_data))
ns = network_state.parse_net_config_data(pre_ns)
if not ns:
raise RuntimeError("No valid network_state object created from"
"input data")
if args.debug:
sys.stderr.write('\n'.join([
"", "Internal State",
yaml.dump(ns, default_flow_style=False, indent=4), ""]))
distro_cls = distros.fetch(args.distro)
distro = distro_cls(args.distro, {}, None)
config = {}
if args.output_kind == "eni":
r_cls = eni.Renderer
config = distro.renderer_configs.get('eni')
elif args.output_kind == "netplan":
r_cls = netplan.Renderer
config = distro.renderer_configs.get('netplan')
else:
r_cls = sysconfig.Renderer
config = distro.renderer_configs.get('sysconfig')
r = r_cls(config=config)
sys.stderr.write(''.join([
"Read input format '%s' from '%s'.\n" % (
args.kind, args.network_data.name),
"Wrote output format '%s' to '%s'\n" % (
args.output_kind, args.directory)]) + "\n")
r.render_network_state(network_state=ns, target=args.directory)
