eole-one-master/postservice/31-one-netmng

376 lines
13 KiB
Plaintext
Raw Normal View History

#!/usr/bin/env python
from pyeole import process
from pyeole.log import init_logging
from creole.client import CreoleClient
from tempfile import mkstemp
import sys
import os
import csv
import logging
import re
LOG_FILE = '/var/log/one/eole-one-node.log'
logger = None
class RunCmdError(Exception):
pass
class OneClient():
def __init__(self, user):
self.user = None
self.auth = None
self.root = '/var/lib/one'
if user:
self.user = user
else:
self.user = 'oneadmin'
user_info = process.system_out(['getent', 'passwd', user])[1]
if user_info:
self.root = user_info.split(':')[5]
command = ['cat', u'{0}/.one/one_auth'.format(self.root)]
res = process.system_out(command)
if res[0] == 0:
self.auth = res[1].split(':')
else:
msg = u"OneClient: unable to authenticate: '{stdout}', '{stderr}'"
logger.error(msg.format(stdout=res[1], stderr=res[2]))
def __run_cmd__(self, cmd):
logger.debug(u"OneClient: execute command '{cmd}'".format(cmd=cmd))
command = list(cmd)
command.extend(['--user', self.auth[0]])
command.extend(['--password', self.auth[1]])
res = process.system_out(command)
if res[0] == 0:
if 'list' in cmd:
out_lines = []
if res:
for line in res[1].split('\n'):
if len(line) == 0:
next
elif re.match('^.*ID ', line):
next
else:
out_lines.append(line.split())
return out_lines
else:
return res
else:
msg = u"OneClient: error executing '{cmd}': '{stdout}', '{stderr}'"
logger.error(msg.format(cmd=cmd, stdout=res[1], stderr=res[2]))
return False
def get_hosts(self):
""" get the list of hosts
"""
logger.debug(u"OneClient: list all hosts")
cmd = ['onehost', 'list']
cmd.extend(['-l', 'ID,NAME'])
res = self.__run_cmd__(cmd)
return(res)
def get_clusters(self):
""" get the cluster list
"""
logger.debug(u"OneClient: list all clusters")
cmd = ['onecluster', 'list']
cmd.extend(['-l', 'ID,NAME'])
return self.__run_cmd__(cmd)
def get_networks(self):
""" get the virtual network list
"""
logger.debug(u"OneClient: list all networks")
cmd = ['onevnet', 'list']
cmd.extend(['-l', 'ID,NAME'])
return self.__run_cmd__(cmd)
def get_cluster_id_by_name(self, name):
logger.debug(u"OneClient: get cluster named '{name}'".format(name=name))
cmd = ['onecluster', 'list']
cmd.extend(['-f', 'NAME={0}'.format(name)])
res = self.__run_cmd__(cmd)
ID = res[0][0]
return ID
def get_vnet_id_by_name(self, name):
logger.debug(u"OneClient: get network named '{name}'".format(name=name))
cmd = ['onevnet', 'list']
cmd.extend(['-f', 'NAME={0}'.format(name)])
res = self.__run_cmd__(cmd)
ID = res[0][0]
return ID
def create_network(self, templatefile, cluster, vnet_name):
""" Create a network
"""
logger.info(u"OneClient: create network named '{name}'".format(name=vnet_name))
cmd = ['onevnet', 'create', templatefile]
res = self.__run_cmd__(cmd)
if res and res[0] == 0:
msg = u"OneClient: attach vnet '{vnet}' to cluster '{cluster}'"
logger.info(msg.format(vnet=vnet_name, cluster=cluster))
clt_id = self.get_cluster_id_by_name(cluster)
vnet_id = self.get_vnet_id_by_name(vnet_name)
res = self.__run_cmd__(['onecluster', 'addvnet', clt_id, vnet_id])
if not res:
print("Error attaching {0} vnet to {1} cluster".format(vnet_name, cluster))
return False
else:
os.remove(templatefile)
return True
else:
logger.error(u"Creation of virtual network with template {0} failed".format(templatefile))
return False
def update_network(self, templatefile, cluster, vnet_name):
""" Update a network
"""
logger.info(u"OneClient: update network named '{name}'".format(name=vnet_name))
vnet_id = self.get_vnet_id_by_name(vnet_name)
cmd = ['onevnet', 'update']
cmd.extend(['--user', self.auth[0]])
cmd.extend(['--password', self.auth[1][:-1]])
cmd.extend([vnet_id, templatefile])
res = process.system_out(cmd)
if res[0] == 0:
os.remove(templatefile)
return True
else:
logger.error(u"Update of virtual network with template {0} failed".format(templatefile))
return False
def delete_network(self, vnet_id):
logger.info(u"OneClient: delete network with ID '{id}'".format(id=vnet_id))
cmd = ['onevnet', 'delete']
cmd.extend(['--user', self.auth[0]])
cmd.extend(['--password', self.auth[1][:-1]])
cmd.append(vnet_id)
res = process.system_out(cmd)
if res[0] == 0:
logger.info(u"Network {0} deleted".format(vnet_id))
return True
else:
logger.error(u"Error deleting network {0}".format(vnet_id))
return False
class OneNetwork():
def create(self, one_client):
logger.debug(u"OneNetwork: create network named '{name}'".format(name=self.zone))
tmpl_file = self.create_template()
if one_client.create_network(tmpl_file, self.cluster, self.zone):
logger.info(u"Virtual network {0} created".format(self.zone))
return True
else:
logger.error(u"Error Creating virtual network {0}".format(self.zone))
return False
def update(self, one_client):
logger.debug(u"OneNetwork: update network named '{name}'".format(name=self.zone))
tmpl_file = self.create_template(True)
if one_client.update_network(tmpl_file, self.cluster, self.zone):
logger.info(u"Virtual network {0} updated".format(self.zone))
return True
else:
logger.error(u"Error Updating virtual network {0}".format(self.zone))
return False
def manage(self, one_client):
logger.debug(u"OneNetwork: manage network named '{name}'".format(name=self.zone))
found = False
vnet = one_client.get_networks()
network_name = self.zone
for net in vnet:
if network_name in net:
found = True
break
if not found:
return self.create(one_client)
else:
return self.update(one_client)
class OneNetworkL3(OneNetwork):
def __init__(self, net_info, cluster):
self.swname = net_info[0]
self.zone = u'{0}{1}'.format(net_info[10], net_info[1])
self.vlan = net_info[2]
self.vnet_addr = net_info[3]
self.vnet_mask = net_info[4]
self.vnet_gw = net_info[5]
self.vnet_rg_start = net_info[6]
self.vnet_rg_size = net_info[7]
self.vnet_dns = net_info[8]
self.vnet_trunk = net_info[9]
self.cluster = cluster
def create_template(self, update=False):
logger.debug(u"OneNetworkL3: create template for network named '{name}'".format(name=self.zone))
fd, tmp_path = mkstemp(prefix='oneVnet-')
template = open(tmp_path, 'w')
template.write('NAME = "{0}"\n'.format(self.zone))
template.write('VN_MAD = ovswitch\n')
if (update is False):
if self.vnet_rg_start and self.vnet_rg_size:
template.write('AR=[\n')
template.write('TYPE = "IP4",\n')
template.write('IP = "{0}",\n'.format(self.vnet_rg_start))
template.write('SIZE = "{0}"\n'.format(self.vnet_rg_size))
template.write(']\n')
else:
template.write('TYPE = FIXED\n')
if self.vlan:
template.write('VLAN = yes\n')
template.write('VLAN_ID = {0}\n'.format(self.vlan))
if self.vnet_trunk:
template.write('VLAN_TAGGED_ID = {0}\n'.format(self.vnet_trunk))
template.write('BRIDGE = {0}\n'.format(self.swname))
template.write('NETWORK_ADDRESS = {0}\n'.format(self.vnet_addr))
template.write('NETWORK_MASK = {0}\n'.format(self.vnet_mask))
template.write('GATEWAY = {0}\n'.format(self.vnet_gw))
template.write('DNS = {0}\n'.format(self.vnet_dns))
template.close()
return tmp_path
class OneNetworkL2(OneNetwork):
def __init__(self, net_info, cluster):
self.swname = net_info[0]
self.zone = u'{0}{1}'.format(net_info[6], net_info[1])
self.net_size = net_info[2]
self.first_mac = net_info[3]
self.tag = net_info[4]
self.trunk = net_info[5]
self.cluster = cluster
def create_template(self,update=False):
logger.debug(u"OneNetworkL2: create template for network named '{name}'".format(name=self.zone))
fd, tmp_path = mkstemp(prefix='oneVnet-')
template = open(tmp_path, 'w')
template.write('NAME = "{0}"\n'.format(self.zone))
template.write('VN_MAD = ovswitch\n')
if self.tag:
template.write('VLAN = yes\n')
template.write('VLAN_ID = "{0}"\n'.format(self.tag))
if self.trunk:
template.write('VLAN_TAGGED_ID = "{0}""\n'.format(self.trunk))
template.write('BRIDGE = {0}\n'.format(self.swname))
if update is False and self.net_size:
template.write("AR=[\n")
template.write(' TYPE = "ETHER",\n')
if self.first_mac:
template.write(' MAC = "{0}",\n'.format(self.first_mac))
template.write(' SIZE = "{0}"\n'.format(self.net_size))
template.write("]\n")
template.close()
return tmp_path
def main():
global logger
logger = init_logging(name='postservice.opennebula.network',
level=u'INFO',
as_root=True,
console=True,
syslog=True)
logger.debug(u"Configure OpenNebula networks")
client = CreoleClient()
one_client = OneClient('oneadmin')
networks = []
cluster = client.get_creole('one_cluster_name')
swname = client.get_creole('ovs_sw_name')
zones = client.get_creole('vnets')
vlans = client.get_creole('vnet_vlan_tag')
vnet_addr = client.get_creole('vnet_network_addr')
vnet_mask = client.get_creole('vnet_network_mask')
vnet_dns = client.get_creole('vnet_network_dns')
vnet_gw = client.get_creole('vnet_network_gw')
vnet_rg_start = client.get_creole('vnet_range_start')
vnet_rg_size = client.get_creole('vnet_range_size')
vnet_trunk = client.get_creole('vnet_vlan_trunk')
l2_vnet = client.get_creole('l2_vnets')
l2_vnet_size = client.get_creole('l2_vnet_size')
l2_vnet_vlan_tag = client.get_creole('l2_vnet_vlan_tag')
l2_vnet_vlan_trunk = client.get_creole('l2_vnet_vlan_trunk')
l2_vnet_first_mac = client.get_creole('l2_vnet_first_mac')
net_prefix = "CR_"
processed = []
for cpt in range(len(zones)):
if zones[cpt] not in processed:
info = []
info.append(swname)
info.append(zones[cpt])
info.append(vlans[cpt])
info.append(vnet_addr[cpt])
info.append(vnet_mask[cpt])
info.append(vnet_gw[cpt])
info.append(vnet_rg_start[cpt])
info.append(vnet_rg_size[cpt])
info.append(vnet_dns[cpt])
info.append(vnet_trunk[cpt])
info.append(net_prefix)
networks.append(OneNetworkL3(info, cluster))
processed.append(zones[cpt])
for i in range(len(l2_vnet)):
if l2_vnet[i] not in processed:
net_info = []
net_info.append(swname)
net_info.append(l2_vnet[i])
net_info.append(l2_vnet_size[i])
net_info.append(l2_vnet_first_mac[i])
net_info.append(l2_vnet_vlan_tag[i])
net_info.append(l2_vnet_vlan_trunk[i])
net_info.append(net_prefix)
networks.append(OneNetworkL2(net_info, cluster))
processed.append(l2_vnet[i])
if client.get_creole('activer_openvswitch'):
for network in networks:
if not network.manage(one_client):
exit(1)
else:
logger.info(u'Open vSwitch disabled no need to configure virtual networks')
networks = one_client.get_networks()
for net in networks:
name = net[1]
if name.startswith(net_prefix):
if not name[3:] in zones and not name[3:] in l2_vnet:
one_client.delete_network(net[0])
exit(0)
main()