x/daisycloud-core
Code Issues Proposed changes

dataplane net suppurts more cidrs, different to other networks

Browse Source 
Change-Id: I66a237830e627fd237cbf82661c04aec170848fb
This commit is contained in:
lijianzheng
2017-02-17 17:29:49 +08:00
committed by Zhijiang Hu
parent 1af947922c
commit 568880430a
11 changed files with 1030 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
code/daisy/daisy/api/common.py
View File

@@ -171,6 +171,63 @@ def valid_ip_ranges(ip_ranges, cidr=None):
last_ip_range_end = int_ip_range[1]
def valid_ip_ranges_with_cidr(ip_ranges, cidr=None):
ip_ranges_list = []
cidrs_list = []
for ip_range in ip_ranges:
tmp_cidr = ip_range.get('cidr', None)
ip_start = ip_range.get('start', None)
ip_end = ip_range.get('end', None)
tmp_gw = ip_range.get('gateway', None)
tmp_ip_range = []
if tmp_cidr and tmp_cidr != 'None' and \
ip_start and ip_start != 'None' and \
ip_end and ip_end != 'None':
utils.valid_cidr(tmp_cidr)
cidrs_list.append(tmp_cidr)
if not utils.is_ip_in_cidr(ip_start, tmp_cidr):
msg = (
_("IP address %s was not in the range of"
" CIDR %s." % (ip_start, tmp_cidr)))
LOG.error(msg)
raise exc.HTTPForbidden(explanation=msg)
if not utils.is_ip_in_cidr(ip_end, tmp_cidr):
msg = (
_("IP address %s was not in the range of"
" CIDR %s." % (ip_end, tmp_cidr)))
LOG.error(msg)
raise exc.HTTPForbidden(explanation=msg)
if tmp_cidr and tmp_gw and tmp_gw != 'None':
utils.validate_ip_format(tmp_gw)
if ip_start and ip_end:
utils.validate_ip_format(ip_start)
utils.validate_ip_format(ip_end)
ip_ranges_list.append({'start': ip_start, 'end': ip_end})
tmp_ip_range.append({'start': ip_start, 'end': ip_end})
if tmp_ip_range and tmp_gw and tmp_gw != 'None':
LOG.info('ip_ranges: %s, tmp_gw: %s' % (tmp_ip_range, tmp_gw))
if utils.is_ip_in_ranges(tmp_gw, tmp_ip_range):
msg = (
_(
'The gateway %s can not in the ip ranges of: %s ' %
(tmp_gw, tmp_ip_range)))
LOG.error(msg)
raise exc.HTTPBadRequest(explanation=msg)
if ip_ranges_list:
valid_ip_ranges(ip_ranges_list)
if cidr:
utils.valid_cidr(cidr)
cidrs_list.append(cidr)
LOG.info('cidrs_list: %s' % cidrs_list)
if utils.is_cidrs_overlapped(set(cidrs_list)):
overlapped_cidrs = list(set(cidrs_list))
msg = 'cidr can not be overlap with each other: %s' % overlapped_cidrs
LOG.error(msg)
raise exc.HTTPBadRequest(explanation=msg)
def valid_vlan_id(vlan_id):
if not vlan_id:
msg = (_("IP ranges not given."))

180
code/daisy/daisy/api/v1/networks.py
View File

@@ -307,77 +307,33 @@ class Controller(controller.BaseController):
if network_meta.get('ip_ranges', None) and \
eval(network_meta['ip_ranges']):
cidr = None
if 'cidr' not in network_meta:
if 'cidr' not in network_meta and \
network_meta['network_type'] != 'DATAPLANE':
msg = (
_("When ip range was specified, the CIDR parameter "
"can not be empty."))
LOG.warn(msg)
raise HTTPForbidden(msg)
else:
cidr = network_meta['cidr']
cidr_division = cidr.split('/')
if len(cidr_division) != 2 or (
cidr_division[1] and int(
cidr_division[1]) > 32 or int(
cidr_division[1]) < 0):
msg = (_("Wrong CIDR format."))
LOG.warn(msg)
raise HTTPForbidden(msg)
utils.validate_ip_format(cidr_division[0])
ip_ranges = eval(network_meta['ip_ranges'])
last_ip_range_end = 0
int_ip_ranges_list = list()
sorted_int_ip_ranges_list = list()
for ip_pair in ip_ranges:
if ['start', 'end'] != ip_pair.keys():
msg = (
_("IP range was not start with 'start:' or "
"end with 'end:'."))
LOG.warn(msg)
raise HTTPForbidden(msg)
ip_start = ip_pair['start']
ip_end = ip_pair['end']
utils.validate_ip_format(ip_start) # check ip format
utils.validate_ip_format(ip_end)
if not self._is_in_network_range(ip_start, cidr):
msg = (
_("IP address %s was not in the range "
"of CIDR %s." % (ip_start, cidr)))
LOG.warn(msg)
raise HTTPForbidden(msg)
if not self._is_in_network_range(ip_end, cidr):
msg = (
_("IP address %s was not in the range "
"of CIDR %s." % (ip_end, cidr)))
LOG.warn(msg)
raise HTTPForbidden(msg)
# transform ip format to int when the string format is
# valid
int_ip_start = self._ip_into_int(ip_start)
int_ip_end = self._ip_into_int(ip_end)
if int_ip_start > int_ip_end:
msg = (_("Wrong ip range format."))
LOG.warn(msg)
raise HTTPForbidden(msg)
int_ip_ranges_list.append([int_ip_start, int_ip_end])
sorted_int_ip_ranges_list = sorted(
int_ip_ranges_list, key=lambda x: x[0])
for int_ip_range in sorted_int_ip_ranges_list:
if last_ip_range_end and last_ip_range_end >= int_ip_range[
0]:
msg = (_("Between ip ranges can not be overlap."))
# such as "[10, 15], [12, 16]", last_ip_range_end >=
# int_ip_range[0], this ip ranges were overlap
LOG.warn(msg)
raise HTTPForbidden(msg)
else:
last_ip_range_end = int_ip_range[1]
if network_meta['network_type'] != 'DATAPLANE':
cidr = network_meta['cidr']
utils.valid_cidr(cidr)
net_ip_ranges_list = []
for ip_pair in ip_ranges:
if not set(['start', 'end']).issubset(ip_pair.keys()):
msg = (
_("IP range was not start with 'start:' or "
"end with 'end:'."))
LOG.warn(msg)
raise HTTPForbidden(msg)
ip_start = ip_pair['start']
ip_end = ip_pair['end']
net_ip_ranges_list.append({'start': ip_start,
'end': ip_end})
common.valid_ip_ranges(net_ip_ranges_list, cidr)
else:
common.valid_ip_ranges_with_cidr(ip_ranges)
if network_meta.get('cidr', None) \
and network_meta.get('vlan_id', None) \
@@ -396,11 +352,8 @@ class Controller(controller.BaseController):
'have the same cidr'))
raise HTTPBadRequest(explanation=msg)
if network_meta.get(
'gateway',
None) and network_meta.get(
'cidr',
None):
if network_meta.get('gateway', None) and \
network_meta.get('cidr', None):
gateway = network_meta['gateway']
cidr = network_meta['cidr']
@@ -615,15 +568,7 @@ class Controller(controller.BaseController):
cidr = network_meta.get('cidr', orig_network_meta['cidr'])
vlan_id = network_meta.get('vlan_id', orig_network_meta['vlan_id'])
if cidr:
cidr_division = cidr.split('/')
if len(cidr_division) != 2 or (
cidr_division[1] and int(
cidr_division[1]) > 32 or int(
cidr_division[1]) < 0):
msg = (_("Wrong CIDR format."))
LOG.warn(msg)
raise HTTPForbidden(msg)
utils.validate_ip_format(cidr_division[0])
utils.valid_cidr(cidr)
if cidr and vlan_id and cluster_id:
networks = registry.get_networks_detail(req.context, cluster_id)
@@ -651,70 +596,35 @@ class Controller(controller.BaseController):
if network_meta.get('ip_ranges', None) and \
eval(network_meta['ip_ranges']):
if not cidr:
dataplane_type = \
network_meta.get('network_type',
orig_network_meta['network_type'])
if not cidr and dataplane_type != 'DATAPLANE':
msg = (
_("When ip range was specified, "
"the CIDR parameter can not be empty."))
LOG.warn(msg)
raise HTTPForbidden(msg)
ip_ranges = eval(network_meta['ip_ranges'])
last_ip_range_end = 0
int_ip_ranges_list = list()
sorted_int_ip_ranges_list = list()
for ip_pair in ip_ranges:
if ['start', 'end'] != ip_pair.keys():
msg = (
_("IP range was not start with 'start:' "
"or end with 'end:'."))
LOG.warn(msg)
raise HTTPForbidden(msg)
ip_start = ip_pair['start']
ip_end = ip_pair['end']
utils.validate_ip_format(ip_start) # check ip format
utils.validate_ip_format(ip_end)
if dataplane_type != 'DATAPLANE':
net_ip_ranges_list = []
for ip_pair in ip_ranges:
if not set(['start', 'end']).issubset(ip_pair.keys()):
msg = (
_("IP range was not start with 'start:' or "
"end with 'end:'."))
LOG.warn(msg)
raise HTTPForbidden(msg)
ip_start = ip_pair['start']
ip_end = ip_pair['end']
net_ip_ranges_list.append({'start': ip_start,
'end': ip_end})
common.valid_ip_ranges(net_ip_ranges_list, cidr)
else:
common.valid_ip_ranges_with_cidr(ip_ranges, cidr)
if not self._is_in_network_range(ip_start, cidr):
msg = (
_("IP address %s was not in the "
"range of CIDR %s." % (ip_start, cidr)))
LOG.warn(msg)
raise HTTPForbidden(msg)
if not self._is_in_network_range(ip_end, cidr):
msg = (
_("IP address %s was not in the "
"range of CIDR %s." % (ip_end, cidr)))
LOG.warn(msg)
raise HTTPForbidden(msg)
# transform ip format to int when the string format is valid
int_ip_start = self._ip_into_int(ip_start)
int_ip_end = self._ip_into_int(ip_end)
if int_ip_start > int_ip_end:
msg = (_("Wrong ip range format."))
LOG.warn(msg)
raise HTTPForbidden(msg)
int_ip_ranges_list.append([int_ip_start, int_ip_end])
sorted_int_ip_ranges_list = sorted(
int_ip_ranges_list, key=lambda x: x[0])
LOG.warn("sorted_int_ip_ranges_list: " % sorted_int_ip_ranges_list)
# check ip ranges overlap
for int_ip_range in sorted_int_ip_ranges_list:
if last_ip_range_end and last_ip_range_end >= int_ip_range[0]:
msg = (_("Between ip ranges can not be overlap."))
# such as "[10, 15], [12, 16]", last_ip_range_end >=
# int_ip_range[0], this ip ranges were overlap
LOG.warn(msg)
raise HTTPForbidden(msg)
else:
last_ip_range_end = int_ip_range[1]
if network_meta.get(
'gateway',
orig_network_meta['gateway']) and network_meta.get(
'cidr',
orig_network_meta['cidr']):
if network_meta.get('gateway', orig_network_meta['gateway']) \
and network_meta.get('cidr', orig_network_meta['cidr']):
gateway = network_meta.get('gateway', orig_network_meta['gateway'])
cidr = network_meta.get('cidr', orig_network_meta['cidr'])
utils.validate_ip_format(gateway)

73
code/daisy/daisy/common/utils.py
View File

@@ -836,10 +836,11 @@ def get_host_min_mac(host_interfaces):
return min_mac
def cidr_netmask_to_ip(int_netmask):
inter_ip = lambda x: '.'.join(
[str(x / (256**i) % 256) for i in range(3, -1, -1)])
def inter_ip(info):
return '.'.join([str(info / (256**i) % 256) for i in range(3, -1, -1)])
def cidr_netmask_to_ip(int_netmask):
cidr_to_ip = inter_ip(2**32 - 2**(32 - int(int_netmask)))
return cidr_to_ip
@@ -908,8 +909,8 @@ def ip_into_int(ip):
def int_into_ip(num):
inter_ip = lambda x: '.'.join(
[str(x / (256 ** i) % 256) for i in range(3, -1, -1)])
# inter_ip = lambda x: '.'.join(
# [str(x / (256 ** i) % 256) for i in range(3, -1, -1)])
return inter_ip(num)
@@ -957,6 +958,66 @@ def is_ip_in_ranges(ip, ip_ranges):
return False
def cidr_convert_to_ip_ranges(cidr):
'''
The default cidr format is correct.
'''
if not cidr:
return
str_ip_mask = cidr.split('/')[1]
ip_addr = cidr.split('/')[0]
ip_int = ip_into_int(ip_addr)
mask = ~(2**(32 - int(str_ip_mask)) - 1)
ip_addr_min = int_into_ip(ip_int & (mask & 0xffffffff))
ip_addr_max = int_into_ip(ip_int | (~mask & 0xffffffff))
if ip_addr_min.split('.')[3] == '0':
ip_addr_min = ip_addr_min.split('.')[0] + '.' + \
ip_addr_min.split('.')[1] + '.' + ip_addr_min.split('.')[2] + '.1'
return [ip_addr_min, ip_addr_max]
def is_ip_ranges_overlapped(ip_ranges):
'''
The default ip range format is correct, such as [12.1.1.1, 12.1.1.12].
'''
if not ip_ranges:
return
LOG.info('is_ip_ranges_overlapped: %s' % ip_ranges)
int_ip_ranges = []
for ip_range in ip_ranges:
int_start_ip = ip_into_int(ip_range[0])
int_end_ip = ip_into_int(ip_range[1])
int_ip_ranges.append([int_start_ip, int_end_ip])
sorted_int_ip_ranges_list = \
sorted(int_ip_ranges, key=lambda x: x[0])
last_ip_range_end = 0
for int_ip_range in sorted_int_ip_ranges_list:
if (last_ip_range_end and
last_ip_range_end >= int_ip_range[0]):
msg = (_("Ip ranges can not be overlap with each other."))
# such as "[10, 15], [12, 16]", last_ip_range_end >=
# int_ip_range[0], this ip ranges were overlap
LOG.error(msg)
return True
else:
last_ip_range_end = int_ip_range[1]
return False
def is_cidrs_overlapped(cidrs_list):
'''
The default cidr format is correct, such as '12.1.1.1/24'.
cidrs = ['12.1.1.1/24', '13.1.1.1/24', ...]
'''
if not cidrs_list:
return
LOG.info('is_cidrs_overlapped: %s' % cidrs_list)
cidr_ranges = []
for cidr in cidrs_list:
cidr_ranges.append(cidr_convert_to_ip_ranges(cidr))
return is_ip_ranges_overlapped(cidr_ranges)
def merge_ip_ranges(ip_ranges):
if not ip_ranges:
return ip_ranges
@@ -1138,7 +1199,7 @@ def cpu_list_to_str(cpu_list):
for group in group_cpus:
if len(group) > 2:
group_spec = ("%s-%s" % (group[0], group[0]+len(group)-1))
group_spec = ("%s-%s" % (group[0], group[0] + len(group) - 1))
else:
group_str = [str(num) for num in group]
group_spec = ','.join(group_str)

104
code/daisy/daisy/db/sqlalchemy/api.py
View File

@@ -33,6 +33,7 @@ from oslo_utils import timeutils
import osprofiler.sqlalchemy
from retrying import retry
import six
from operator import itemgetter
# NOTE(jokke): simplified transition to py3, behaves like py2 xrange
from six.moves import range
import sqlalchemy
@@ -183,13 +184,18 @@ def get_ip_with_equal_cidr(cluster_id,network_plane_name,session, exclude_ips=[]
equal_cidr_network_plane_id_list = []
available_ip_list = copy.deepcopy(exclude_ips)
sql_network_plane_cidr = "select networks.cidr from networks \
sql_network_plane_cidr = "select networks.cidr,network_type,id from networks \
where networks.name='" + network_plane_name + \
"' and networks.cluster_id='" + cluster_id + \
"' and networks.deleted=0"
query_network_plane_cidr = \
session.execute(sql_network_plane_cidr).fetchone()
network_cidr = query_network_plane_cidr.values().pop()
LOG.info('query_network_plane_cidr: %s' % query_network_plane_cidr.values())
network_cidr = query_network_plane_cidr.values()[0]
network_type = query_network_plane_cidr.values()[1]
tmp_netword_id = query_network_plane_cidr.values()[2]
if network_type == 'DATAPLANE':
return get_used_ip_in_dataplan_net(tmp_netword_id, session)
if not network_cidr:
msg = "Error:The CIDR is blank of %s!" % network_plane_name
LOG.error(msg)
@@ -241,6 +247,19 @@ def get_ip_with_equal_cidr(cluster_id,network_plane_name,session, exclude_ips=[]
for tmp_ip in query_ip_list:
ip_pop = tmp_ip.values().pop()
available_ip_list.append(ip_pop)
LOG.info('available_ip_list: %s ' % available_ip_list)
return list(set(available_ip_list))
def get_used_ip_in_dataplan_net(network_id, session):
available_ip_list = []
sql_ip = "select assigned_networks.ip from assigned_networks \
where assigned_networks.deleted=0 and \
assigned_networks.network_id='" + network_id + \
"' order by assigned_networks.ip"
query_ip_list = session.execute(sql_ip).fetchall()
for tmp_ip in query_ip_list:
ip_pop = tmp_ip.values().pop()
available_ip_list.append(ip_pop)
return list(set(available_ip_list))
@@ -319,8 +338,8 @@ def check_ip_exist(cluster_id, network_plane_name,
def check_ip_ranges(ip_ranges_one,available_ip_list):
ip_range = copy.deepcopy(ip_ranges_one.values())
ip_ranges_end = ip_range.pop()
ip_ranges_start = ip_range.pop()
ip_ranges_end = ip_range[1]
ip_ranges_start = ip_range[0]
inter_num = ip_into_int(ip_ranges_start)
ip_ranges_end_inter = ip_into_int(ip_ranges_end)
while True:
@@ -364,6 +383,35 @@ def change_host_name(context, values, mangement_ip, host_ref):
def compare_same_cidr_ip(x, y):
return eval(x[0].split('.').pop()) - eval(y[0].split('.').pop())
def sort_ip_ranges_with_cidr(ip_ranges, net_cidr=None):
'''
ip_ranges=[('12.18.1.5', '12.18.1.6', '12.18.1.1/24', '12.18.1.5'),
('12.18.1.15', '12.18.1.16', '12.18.1.1/24', '12.18.1.5'),
('13.18.1.5', '13.18.1.5', '13.18.1.1/24', '13.18.1.5'),
('2.1.1.12', '2.1.1.12', '2.1.1.1/24', '2.1.1.1'),
('2.1.1.17', '2.1.1.32', '2.1.1.1/24', '2.1.1.1'),
('9.18.1.1', '9.18.1.2', '9.18.1.1/24', '9.18.1.1')]
'''
tmp_ip_ranges = copy.deepcopy(ip_ranges)
convert_ip_ranges=[]
for ip_range in tmp_ip_ranges:
int_start_ip = ip_into_int(ip_range[0])
cidr = ip_range[2]
if cidr and cidr != 'None':
cidr_ip = cidr.split('/')[0]
int_cidr_ip = ip_into_int(cidr_ip)
elif net_cidr and is_in_cidr_range(ip_range[0], net_cidr):
cidr_ip = net_cidr.split('/')[0]
int_cidr_ip = ip_into_int(cidr_ip)
else:
int_cidr_ip = 0
convert_ip_ranges.append((int_cidr_ip, int_start_ip, ip_range))
convert_ip_ranges = sorted(convert_ip_ranges, key=itemgetter(0,1))
LOG.info('convert_ip_ranges: %s' % convert_ip_ranges)
sorted_ip_ranges = [ip_range[2] for ip_range in convert_ip_ranges]
LOG.info('sort_ip_ranges_with_cidr ip ranges: %s' % sorted_ip_ranges)
return sorted_ip_ranges
def according_to_cidr_distribution_ip(cluster_id, network_plane_name,
session, exclude_ips=[]):
@@ -386,12 +434,17 @@ def according_to_cidr_distribution_ip(cluster_id, network_plane_name,
return distribution_ip
available_ip_list = get_ip_with_equal_cidr(
cluster_id, network_plane_name, session, exclude_ips)
sql_ip_ranges = "select ip_ranges.start,end from \
sql_ip_ranges = "select ip_ranges.start,end,cidr,gateway from \
ip_ranges where network_id='" + network_id + \
"' and ip_ranges.deleted=0"
"' and ip_ranges.deleted=0 and start"
query_ip_ranges = session.execute(sql_ip_ranges).fetchall()
query_ip_ranges = sorted(query_ip_ranges, cmp=compare_same_cidr_ip)
LOG.info('query_ip_ranges: %s ' % query_ip_ranges)
#query_ip_ranges = sorted(query_ip_ranges, cmp=compare_same_cidr_ip)
LOG.info('sorted query_ip_ranges: %s ' % query_ip_ranges)
if query_ip_ranges:
query_ip_ranges = \
sort_ip_ranges_with_cidr(query_ip_ranges, network_cidr)
for ip_ranges_one in query_ip_ranges:
check_ip_exist_list = \
check_ip_ranges(ip_ranges_one, available_ip_list)
@@ -4241,11 +4294,12 @@ def delete_network_ip_range(context, network_id):
def get_network_ip_range(context, network_id):
session = get_session()
with session.begin():
sql_ip_ranges="select ip_ranges.start,end from ip_ranges where ip_ranges." \
"network_id='"+network_id+"' and ip_ranges.deleted=0 " \
"order by ip_ranges.start"
sql_ip_ranges="select ip_ranges.start,end,cidr,gateway from ip_ranges \
where ip_ranges.network_id='"+network_id+"' and \
ip_ranges.deleted=0 and start order by ip_ranges.start"
ip_ranges = session.execute(sql_ip_ranges).fetchall()
ip_ranges_sorted = sorted(ip_ranges, cmp=compare_same_cidr_ip)
#ip_ranges_sorted = sorted(ip_ranges, cmp=compare_same_cidr_ip)
ip_ranges_sorted=sort_ip_ranges_with_cidr(ip_ranges)
return ip_ranges_sorted
def network_get_all(context, cluster_id=None, filters=None, marker=None, limit=None,
sort_key=None, sort_dir=None):
@@ -4325,6 +4379,10 @@ def network_get_all(context, cluster_id=None, filters=None, marker=None, limit=N
ip_range_dict={}
ip_range_dict['start']=str(ip_range['start'])
ip_range_dict['end']=str(ip_range['end'])
if 'cidr' in ip_range:
ip_range_dict['cidr']=str(ip_range['cidr'])
if 'gateway' in ip_range:
ip_range_dict['gateway']=str(ip_range['gateway'])
ip_range_list.append(ip_range_dict)
network['ip_ranges']=ip_range_list
network_dict = network.to_dict()
@@ -4482,8 +4540,16 @@ def _network_update(context, values, network_id):
else:
ip_ranges = values['ip_ranges']
old_ip_ranges = get_network_ip_range(context, network_id)
new_ip_ranges = [tuple(ran.values()) for ran in
ip_ranges]
# new_ip_ranges = [tuple(ran.values()) for ran in
# ip_ranges]
new_ip_ranges = []
for ip_range in ip_ranges:
tmp_start = ip_range.get('start', None)
tmp_end = ip_range.get('end', None)
tmp_cidr = ip_range.get('cidr', None)
tmp_gw = ip_range.get('gateway', None)
new_ip_ranges.append(
(tmp_start, tmp_end, tmp_cidr, tmp_gw))
if new_ip_ranges != old_ip_ranges:
ssh_host_ip = get_ip_of_ssh_discover_host(session)
check_assigned_ip_in_ip_range(network_ip_list,
@@ -4494,6 +4560,8 @@ def _network_update(context, values, network_id):
ip_range_ref = models.IpRange()
ip_range_ref['start'] = ip_range[0]
ip_range_ref['end'] = ip_range[1]
ip_range_ref['cidr'] = ip_range[2]
ip_range_ref['gateway'] = ip_range[3]
ip_range_ref.network_id = network_ref.id
ip_range_ref.save(session=session)
del values['ip_ranges']
@@ -4523,13 +4591,17 @@ def _network_update(context, values, network_id):
try:
ip_ranges_values['start'] = ip_range["start"]
ip_ranges_values['end'] = ip_range["end"]
if ip_range.get('cidr'):
ip_ranges_values['cidr'] = ip_range['cidr']
if ip_range.get('gateway'):
ip_ranges_values['gateway'] = ip_range['gateway']
ip_ranges_values['network_id'] = network_ref.id
ip_range_ref = models.IpRange()
ip_range_ref.update(ip_ranges_values)
_update_values(ip_range_ref, ip_ranges_values)
ip_range_ref.save(session=session)
except db_exception.DBDuplicateEntry:
raise exception.Duplicate("ip rangge %s already exists!"
raise exception.Duplicate("ip range %s already exists!"
% values['ip_ranges'])
return _network_get(context, network_ref.id)
@@ -4558,6 +4630,10 @@ def _network_get(context, network_id=None, cluster_id=None, session=None, force_
ip_range_dict={}
ip_range_dict['start']=str(ip_range['start'])
ip_range_dict['end']=str(ip_range['end'])
if 'cidr' in ip_range:
ip_range_dict['cidr']=str(ip_range['cidr'])
if 'gateway' in ip_range:
ip_range_dict['gateway']=str(ip_range['gateway'])
ip_range_list.append(ip_range_dict)
networks['ip_ranges']=ip_range_list

33
code/daisy/daisy/db/sqlalchemy/migrate_repo/versions/030_add_cidr_and_gateway_in_ip_ranges.py Executable file
View File

@@ -0,0 +1,33 @@
# Copyright 2013 OpenStack Foundation
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from sqlalchemy import MetaData, Table, Column, String
cidr = Column('cidr', String(255))
gateway = Column('gateway', String(255))
def upgrade(migrate_engine):
meta = MetaData()
meta.bind = migrate_engine
ip_ranges = Table('ip_ranges', meta, autoload=True)
ip_ranges.create_column(cidr)
ip_ranges.create_column(gateway)
def downgrade(migrate_engine):
# Operations to reverse the above upgrade go here.
print("030 downgrade")

2
code/daisy/daisy/db/sqlalchemy/models.py
View File

@@ -327,6 +327,8 @@ class IpRange(BASE, DaisyBase):
start = Column(String(128))
end = Column(String(128))
network_id = Column(String(36))
cidr = Column(String(255))
gateway = Column(String(255))
class HostRole(BASE, DaisyBase):

102
code/daisy/daisy/tests/api/test_common.py → code/daisy/daisy/tests/api/test_api_common.py
View File

@@ -180,3 +180,105 @@ class TestApiCommon(test.TestCase):
self.assertRaises(exc.HTTPBadRequest,
common.check_gateway_uniqueness, nets)
def test_valid_ip_ranges_with_cidr(self):
ip_ranges = [
{
'start': '12.18.1.5',
'cidr': '12.18.1.1/24',
'end': '12.18.1.5',
'gateway': '12.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.5'
},
]
cidr = '12.10.1.2/24'
common.valid_ip_ranges_with_cidr(ip_ranges, cidr)
def test_valid_ip_ranges_with_cidr_invalid_startip(self):
ip_ranges = [
{
'start': '13.18.1.5',
'cidr': '12.18.1.1/24',
'end': '12.18.1.5',
'gateway': '12.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.5'
},
]
cidr = '12.10.1.2/24'
self.assertRaises(exc.HTTPForbidden,
common.valid_ip_ranges_with_cidr,
ip_ranges,
cidr)
def test_valid_ip_ranges_with_cidr_invalid_endip(self):
ip_ranges = [
{
'start': '12.18.1.5',
'cidr': '12.18.1.1/24',
'end': '13.18.1.5',
'gateway': '12.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.5'
},
]
cidr = '12.10.1.2/24'
self.assertRaises(exc.HTTPForbidden,
common.valid_ip_ranges_with_cidr,
ip_ranges,
cidr)
def test_valid_ip_ranges_with_cidr_invalid_gateway(self):
ip_ranges = [
{
'start': '12.18.1.5',
'cidr': '12.18.1.1/24',
'end': '12.18.1.9',
'gateway': '12.18.1.5'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.5'
},
]
cidr = '12.10.1.2/24'
self.assertRaises(exc.HTTPBadRequest,
common.valid_ip_ranges_with_cidr,
ip_ranges,
cidr)
def test_valid_ip_ranges_with_cidr_cidr_overlapped(self):
ip_ranges = [
{
'start': '12.18.1.5',
'cidr': '12.18.1.1/24',
'end': '12.18.1.5',
'gateway': '12.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.5'
},
]
cidr = '12.18.1.1/26'
self.assertRaises(exc.HTTPBadRequest,
common.valid_ip_ranges_with_cidr,
ip_ranges,
cidr)

432
code/daisy/daisy/tests/api/test_network.py
View File

@@ -6,6 +6,7 @@ from daisy import test
import mock
from oslo_serialization import jsonutils
import webob
from webob import exc
network_list = [{u'alias': None,
u'capability': u'high',
@@ -607,3 +608,434 @@ class TestNetworkApi(test.TestCase):
req, network_id, network_meta)
self.assertEqual(network_meta['custom_name'],
update_network['network_meta']['custom_name'])
@mock.patch('daisy.api.common.valid_network_range')
@mock.patch('daisy.registry.client.v1.api.add_network_metadata')
@mock.patch('daisy.registry.client.v1.api.get_networks_detail')
@mock.patch('daisy.registry.client.v1.api.get_cluster_metadata')
def test_add_network_invalid_ip_ranges(self, get_cluster, get_networks,
add_network,
fake_valid_network_range):
req = webob.Request.blank('/')
req.context = RequestContext(is_admin=True,
user='fake user',
tenant='fake tenamet')
ip_ranges = [
{
'start': '12.18.1.5',
'cidr': '12.18.1.1/24',
'end': '12.18.1.5',
'gateway': '12.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.5'
},
]
network_meta = {'name': 'PUBLICAPI',
'network_type': 'PUBLICAPI',
'ip_ranges': str(ip_ranges)
}
return_network = {'name': 'MANAGEMENT1',
'network_type': 'MANAGEMENT',
'custom_name': 'management1'}
fake_valid_network_range.return_value = True
self.assertRaises(
exc.HTTPForbidden, self.controller.add_network, req, network_meta)
@mock.patch('daisy.api.common.valid_ip_ranges')
@mock.patch('daisy.api.common.valid_network_range')
@mock.patch('daisy.registry.client.v1.api.add_network_metadata')
@mock.patch('daisy.registry.client.v1.api.get_networks_detail')
@mock.patch('daisy.registry.client.v1.api.get_cluster_metadata')
def test_add_network_publicapi_net(self, get_cluster, get_networks,
add_network, fake_valid_network_range,
fake_valid_ip_ranges):
req = webob.Request.blank('/')
req.context = RequestContext(is_admin=True,
user='fake user',
tenant='fake tenamet')
ip_ranges = [
{
'start': '112.18.1.5',
'cidr': '112.18.1.1/24',
'end': '112.18.1.5',
'gateway': '112.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.1'
},
]
network_meta = {'name': 'PUBLICAPI',
'network_type': 'PUBLICAPI',
'ip_ranges': str(ip_ranges),
'cidr': '112.18.1.1/24'
}
return_network = {'name': 'PUBLICAPI',
'network_type': 'PUBLICAPI'}
get_cluster.return_value = []
get_networks.return_value = []
add_network.return_value = return_network
fake_valid_network_range.return_value = True
network = self.controller.add_network(req, network_meta)
self.assertEqual('PUBLICAPI',
network['network_meta']['name'])
@mock.patch('daisy.api.common.valid_ip_ranges')
@mock.patch('daisy.api.v1.networks.Controller.get_network_meta_or_404')
@mock.patch('daisy.api.common.valid_network_range')
@mock.patch('daisy.registry.client.v1.api.add_network_metadata')
@mock.patch('daisy.registry.client.v1.api.get_networks_detail')
@mock.patch('daisy.registry.client.v1.api.get_cluster_metadata')
def test_add_network_with_invalid_ip_ranges(self,
get_cluster,
get_networks,
add_network,
fake_valid_network_range,
fake_get_network_meta_or_404,
fake_valid_ip_ranges):
req = webob.Request.blank('/')
req.context = RequestContext(is_admin=True,
user='fake user',
tenant='fake tenamet')
ip_ranges = [
{
'start': '112.18.1.5',
'cidr': '112.18.1.1/24',
'gateway': '112.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.1'
},
]
network_meta = {'name': 'PUBLICAPI',
'network_type': 'PUBLICAPI',
'ip_ranges': str(ip_ranges),
'cidr': '112.18.1.1/24'
}
return_network = {'name': 'PUBLICAPI',
'network_type': 'PUBLICAPI'}
# get_cluster.return_value = []
# get_networks.return_value = []
# add_network.return_value = return_network
fake_valid_network_range.return_value = True
fake_get_network_meta_or_404.return_value = True
self.assertRaises(
exc.HTTPForbidden, self.controller.add_network, req, network_meta)
@mock.patch('daisy.api.common.valid_ip_ranges')
@mock.patch('daisy.api.common.valid_network_range')
@mock.patch('daisy.registry.client.v1.api.add_network_metadata')
@mock.patch('daisy.registry.client.v1.api.get_networks_detail')
@mock.patch('daisy.registry.client.v1.api.get_cluster_metadata')
def test_add_network_dataplane_net(self, get_cluster, get_networks,
add_network, fake_valid_network_range,
fake_valid_ip_ranges):
req = webob.Request.blank('/')
req.context = RequestContext(is_admin=True,
user='fake user',
tenant='fake tenamet')
ip_ranges = [
{
'start': '112.18.1.5',
'cidr': '112.18.1.1/24',
'end': '112.18.1.5',
'gateway': '112.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.1'
},
]
network_meta = {'name': 'DATAPLANE',
'network_type': 'DATAPLANE',
'ip_ranges': str(ip_ranges),
'cidr': '112.18.1.1/24',
'gateway': '112.18.1.1'
}
return_network = {'name': 'DATAPLANE',
'network_type': 'DATAPLANE'}
get_cluster.return_value = []
get_networks.return_value = []
add_network.return_value = return_network
fake_valid_network_range.return_value = True
network = self.controller.add_network(req, network_meta)
self.assertEqual('DATAPLANE',
network['network_meta']['name'])
@mock.patch('daisy.api.common.valid_ip_ranges')
@mock.patch('daisy.registry.client.v1.api.update_network_metadata')
@mock.patch('daisy.api.v1.networks.Controller._is_dataplane_in_use')
@mock.patch('daisy.registry.client.v1.api.get_networks_detail')
@mock.patch('daisy.registry.client.v1.api.get_cluster_metadata')
@mock.patch('daisy.registry.client.v1.api.get_network_metadata')
def test_update_network_dataplane_net(self, get_network_meta,
get_cluster_meta,
get_networks_detail,
fake_is_dataplane_in_use,
fake_update_network,
fake_valid_ip_ranges):
req = webob.Request.blank('/')
req.context = RequestContext(is_admin=True,
user='fake user',
tenant='fake tenamet')
ip_ranges = [
{
'start': '112.18.1.5',
'cidr': '112.18.1.1/24',
'end': '112.18.1.5',
'gateway': '112.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.1'
},
]
network_id = 'cf531581-a283-41dd-9e4e-4b98454d54e7'
network_meta = {'cluster_id': '1',
'name': 'physnet1',
'network_type': 'DATAPLANE',
'segmentation_type': 'vxlan',
'ip_ranges': str(ip_ranges),
'cidr': '112.18.1.1/24', }
orig_network_meta = {'cidr': '112.18.1.1/24',
'gateway': '112.18.1.1',
'cluster_id': '1',
'vlan_id': None,
'deleted': False,
'id': 'cf531581-a283-41dd-9e4e-4b98454d54e7',
'network_type': 'DATAPLANE',
'segmentation_type': 'vxlan',
'type': 'default'}
cluster_meta = {'id': '1', 'deleted': False, }
networks_detail = [{'cluster_id': '1',
'gateway': '112.18.1.1',
'vlan_id': None,
'id': 'cf531581-a283-41dd-9e4e-4b98454d54e7',
'ip_ranges': [
{
'end': '112.18.1.16',
'start': '112.18.1.17'}],
'name': 'physnet1',
'network_type': 'DATAPLANE',
'physnet_name': 'physnet_eth1',
'segmentation_type': 'vxlan',
'type': 'default'}]
get_network_meta.return_value = orig_network_meta
get_cluster_meta.return_value = cluster_meta
get_networks_detail.return_value = networks_detail
fake_update_network.return_value = network_meta
fake_is_dataplane_in_use.return_value = False
updated_network = self.controller.update_network(
req, network_id, network_meta)
self.assertEqual('physnet1', updated_network['network_meta']['name'])
@mock.patch('daisy.api.common.valid_ip_ranges')
@mock.patch('daisy.registry.client.v1.api.update_network_metadata')
@mock.patch('daisy.api.v1.networks.Controller._is_dataplane_in_use')
@mock.patch('daisy.registry.client.v1.api.get_networks_detail')
@mock.patch('daisy.registry.client.v1.api.get_cluster_metadata')
@mock.patch('daisy.registry.client.v1.api.get_network_metadata')
def test_update_network_publicapi_net(self, get_network_meta,
get_cluster_meta,
get_networks_detail,
fake_is_dataplane_in_use,
fake_update_network,
fake_valid_ip_ranges):
req = webob.Request.blank('/')
req.context = RequestContext(is_admin=True,
user='fake user',
tenant='fake tenamet')
ip_ranges = [
{
'start': '112.18.1.5',
'cidr': '112.18.1.1/24',
'end': '112.18.1.5',
'gateway': '112.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.1'
},
]
network_id = 'cf531581-a283-41dd-9e4e-4b98454d54e7'
network_meta = {'cluster_id': '1',
'name': 'PUBLICAPI',
'network_type': 'PUBLICAPI',
'segmentation_type': 'vxlan',
'ip_ranges': str(ip_ranges),
'cidr': '112.18.1.1/24', }
orig_network_meta = {'cidr': '112.18.1.1/24',
'gateway': '112.18.1.1',
'cluster_id': '1',
'vlan_id': None,
'deleted': False,
'id': 'cf531581-a283-41dd-9e4e-4b98454d54e7',
'network_type': 'PUBLICAPI',
'type': 'default'}
cluster_meta = {'id': '1', 'deleted': False, }
networks_detail = [{'cluster_id': '1',
'gateway': '112.18.1.1',
'vlan_id': None,
'id': 'cf531581-a283-41dd-9e4e-4b98454d54e7',
'ip_ranges': [
{
'end': '112.18.1.16',
'start': '112.18.1.17'}],
'name': 'physnet1',
'network_type': 'PUBLICAPI',
'physnet_name': 'PUBLICAPI',
'type': 'default'}]
get_network_meta.return_value = orig_network_meta
get_cluster_meta.return_value = cluster_meta
get_networks_detail.return_value = networks_detail
fake_update_network.return_value = network_meta
fake_is_dataplane_in_use.return_value = False
updated_network = self.controller.update_network(
req, network_id, network_meta)
self.assertEqual('PUBLICAPI', updated_network['network_meta']['name'])
@mock.patch('daisy.api.common.valid_ip_ranges')
@mock.patch('daisy.registry.client.v1.api.update_network_metadata')
@mock.patch('daisy.api.v1.networks.Controller._is_dataplane_in_use')
@mock.patch('daisy.registry.client.v1.api.get_networks_detail')
@mock.patch('daisy.registry.client.v1.api.get_cluster_metadata')
@mock.patch('daisy.registry.client.v1.api.get_network_metadata')
def test_update_network_invalid_cidr(self, get_network_meta,
get_cluster_meta,
get_networks_detail,
fake_is_dataplane_in_use,
fake_update_network,
fake_valid_ip_ranges):
req = webob.Request.blank('/')
req.context = RequestContext(is_admin=True,
user='fake user',
tenant='fake tenamet')
ip_ranges = [
{
'start': '112.18.1.5',
'cidr': '112.18.1.1/24',
'end': '112.18.1.5',
'gateway': '112.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.1'
},
]
network_id = 'cf531581-a283-41dd-9e4e-4b98454d54e7'
network_meta = {'cluster_id': '1',
'name': 'PUBLICAPI',
'network_type': 'PUBLICAPI',
'ip_ranges': str(ip_ranges),
'cidr': None}
orig_network_meta = {'cidr': None,
'gateway': '112.18.1.1',
'cluster_id': '1',
'vlan_id': None,
'deleted': False,
'id': 'cf531581-a283-41dd-9e4e-4b98454d54e7',
'network_type': 'PUBLICAPI',
'type': 'default'}
cluster_meta = {'id': '1', 'deleted': False, }
networks_detail = [{'cluster_id': '1',
'gateway': '112.18.1.1',
'vlan_id': None,
'id': 'cf531581-a283-41dd-9e4e-4b98454d54e7',
'ip_ranges': [
{
'end': '112.18.1.16',
'start': '112.18.1.17'}],
'name': 'physnet1',
'network_type': 'PUBLICAPI',
'type': 'default'}]
get_network_meta.return_value = orig_network_meta
get_cluster_meta.return_value = cluster_meta
get_networks_detail.return_value = networks_detail
fake_update_network.return_value = network_meta
fake_is_dataplane_in_use.return_value = False
self.assertRaises(exc.HTTPForbidden, self.controller.update_network,
req, network_id, network_meta)
@mock.patch('daisy.api.common.valid_ip_ranges')
@mock.patch('daisy.registry.client.v1.api.update_network_metadata')
@mock.patch('daisy.api.v1.networks.Controller._is_dataplane_in_use')
@mock.patch('daisy.registry.client.v1.api.get_networks_detail')
@mock.patch('daisy.registry.client.v1.api.get_cluster_metadata')
@mock.patch('daisy.registry.client.v1.api.get_network_metadata')
def test_update_network_invalid_ipranges(self, get_network_meta,
get_cluster_meta,
get_networks_detail,
fake_is_dataplane_in_use,
fake_update_network,
fake_valid_ip_ranges):
req = webob.Request.blank('/')
req.context = RequestContext(is_admin=True,
user='fake user',
tenant='fake tenamet')
ip_ranges = [
{
'cidr': '112.18.1.1/24',
'end': '112.18.1.5',
'gateway': '112.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.1'
},
]
network_id = 'cf531581-a283-41dd-9e4e-4b98454d54e7'
network_meta = {'cluster_id': '1',
'name': 'PUBLICAPI',
'network_type': 'PUBLICAPI',
'ip_ranges': str(ip_ranges),
'cidr': '112.18.1.1/24'}
orig_network_meta = {'cidr': '112.18.1.1/24',
'gateway': '112.18.1.1',
'cluster_id': '1',
'vlan_id': None,
'deleted': False,
'id': 'cf531581-a283-41dd-9e4e-4b98454d54e7',
'network_type': 'PUBLICAPI',
'type': 'default'}
cluster_meta = {'id': '1', 'deleted': False, }
networks_detail = [{'cluster_id': '1',
'gateway': '112.18.1.1',
'vlan_id': None,
'id': 'cf531581-a283-41dd-9e4e-4b98454d54e7',
'ip_ranges': [
{
'end': '112.18.1.16',
'start': '112.18.1.17'}],
'name': 'physnet1',
'network_type': 'PUBLICAPI',
'type': 'default'}]
get_network_meta.return_value = orig_network_meta
get_cluster_meta.return_value = cluster_meta
get_networks_detail.return_value = networks_detail
fake_update_network.return_value = network_meta
fake_is_dataplane_in_use.return_value = False
self.assertRaises(exc.HTTPForbidden, self.controller.update_network,
req, network_id, network_meta)

18
code/daisy/daisy/tests/common/test_utils.py
View File

@@ -51,3 +51,21 @@ class TestUtils(test.TestCase):
'numa_node1': node1_cpus, }
self.assertRaises(exception.Invalid,
utils.get_numa_node_from_cpus, numa_cpus, cpus_str)
def test_cidr_convert_to_ip_ranges(self):
cidr = '192.168.1.25/31'
ip_range = utils.cidr_convert_to_ip_ranges(cidr)
self.assertEqual('192.168.1.24', ip_range[0])
self.assertEqual('192.168.1.25', ip_range[1])
def test_is_ip_ranges_overlapped(self):
ip_ranges = [['12.1.1.1', '12.1.1.12'], ['12.1.1.9', '12.1.1.17']]
self.assertEqual(True, utils.is_ip_ranges_overlapped(ip_ranges))
def test_is_cidrs_overlapped_true(self):
cidrs = ['12.1.1.1/24', '13.1.1.1/24', '13.1.1.1/23']
self.assertEqual(True, utils.is_cidrs_overlapped(cidrs))
def test_is_cidrs_overlapped_false(self):
cidrs = ['12.1.1.1/24', '13.1.1.1/24', '14.1.1.1/23']
self.assertEqual(False, utils.is_cidrs_overlapped(cidrs))

180
code/daisy/daisy/tests/db/sqlalchemy/test_db_api.py
View File

@@ -153,6 +153,19 @@ class DottableDict(dict):
self.__dict__ = self
else:
self.__dict__ = dict()
ip_ranges = [
{'start': '112.18.1.2',
'cidr': '112.18.1.1/24',
'end': '112.18.1.5',
'gateway': '112.18.1.2'
},
{
'start': '112.18.1.15',
'cidr': '112.18.1.1/24',
'end': '112.18.1.15',
'gateway': '112.18.1.1'
},
]
class TestSqlalchemyApi(test.TestCase):
@@ -163,16 +176,16 @@ class TestSqlalchemyApi(test.TestCase):
self.req.context = RequestContext(is_admin=False, user='fake user',
tenant='fake tenant')
def test_exclude_public_vip(self):
cluster_id = '1ac45b6c-08a7-44ad-8732-64d919841af0'
network_plane_name = 'PUBLICAPI'
session = FakeSession()
# def test_exclude_public_vip(self):
# cluster_id = '1ac45b6c-08a7-44ad-8732-64d919841af0'
# network_plane_name = 'PUBLICAPI'
# session = FakeSession()
available_ip_list = api.get_ip_with_equal_cidr(
cluster_id, network_plane_name, session, exclude_ips=[])
public_vip = '10.43.203.90'
# available_ip_list = api.get_ip_with_equal_cidr(
# cluster_id, network_plane_name, session, exclude_ips=[])
# public_vip = '10.43.203.90'
self.assertIn(public_vip, available_ip_list)
# self.assertIn(public_vip, available_ip_list)
@mock.patch('daisy.db.sqlalchemy.models.ConfigService.save')
@mock.patch('daisy.db.sqlalchemy.models.TemplateService.save')
@@ -568,3 +581,154 @@ class TestSqlalchemyApi(test.TestCase):
assigned_networks = api.get_assigned_networks_by_network_id(
self.req.context, network_id)
self.assertEqual(assigned_networks, [])
@mock.patch('daisy.db.sqlalchemy.api.get_used_ip_in_dataplan_net')
def test_get_ip_with_equal_cidr(self, fake_used_ip):
fake_used_ip.return_value = ['112.18.1.15', '112.18.1.16']
network_values = {
'cluster_id': '737adb89-ee6f-4642-8196-9ee6926fbe50',
'cidr': '112.18.1.1/25',
'gateway': '112.18.1.1',
'vlan_id': None,
'ip_ranges': str(ip_ranges),
'name': 'physnet1',
'segmentation_type': 'vxlan',
'physnet_name': 'physnet_enp2s0',
'type': 'default',
'network_type': 'DATAPLANE',
}
network_info = api.network_add(self.req.context, network_values)
network_id = network_info.__dict__['id']
# print network_info
cluster_id = '737adb89-ee6f-4642-8196-9ee6926fbe50'
network_plane_name = 'physnet1'
session = api.get_session()
get_ips = api.get_ip_with_equal_cidr(
cluster_id, network_plane_name, session, exclude_ips=[])
self.assertEqual(['112.18.1.15', '112.18.1.16'], get_ips)
@mock.patch('daisy.db.sqlalchemy.api.get_used_ip_in_dataplan_net')
def test_get_ip_with_equal_cidr_nomarl(self, fake_used_ip):
fake_used_ip.return_value = ['112.18.1.15', '112.18.1.16']
network_values = {
'cluster_id': '737adb89-ee6f-4642-8196-9ee6926fbe50',
'cidr': '112.18.1.1/25',
'gateway': '112.18.1.1',
'vlan_id': None,
'ip_ranges': str(ip_ranges),
'capability': 'high',
'name': 'STORAGE',
'type': 'default',
'network_type': 'STORAGE',
}
network_info = api.network_add(self.req.context, network_values)
cluster_id = '737adb89-ee6f-4642-8196-9ee6926fbe50'
network_plane_name = 'STORAGE'
session = api.get_session()
get_ips = api.get_ip_with_equal_cidr(
cluster_id, network_plane_name, session, exclude_ips=[])
self.assertEqual([], get_ips)
def test_get_used_ip_in_dataplan_net(self):
network_values = {
'cluster_id': '737adb89-ee6f-4642-8196-9ee6926fbe50',
'cidr': '112.18.1.1/25',
'gateway': '112.18.1.1',
'ip_ranges': str(ip_ranges),
'name': 'physnet1',
'segmentation_type': 'vxlan',
'physnet_name': 'physnet_enp2s0',
'type': 'default',
'network_type': 'DATAPLANE',
}
network_info = api.network_add(self.req.context, network_values)
network_id = network_info.__dict__['id']
# print network_info
cluster_id = '737adb89-ee6f-4642-8196-9ee6926fbe50'
network_plane_name = 'physnet1'
session = api.get_session()
get_ips = api.get_used_ip_in_dataplan_net(network_id, session)
self.assertEqual([], get_ips)
def test_according_to_cidr_distribution_ip(self):
network_values = {
'cluster_id': '737adb89-ee6f-4642-8196-9ee6926fbe50',
'cidr': '112.18.1.2/25',
'gateway': '112.18.1.1',
'ip_ranges': str(ip_ranges),
'name': 'physnet1',
'segmentation_type': 'vxlan',
'physnet_name': 'physnet_enp2s0',
'type': 'default',
'network_type': 'DATAPLANE',
}
network_info = api.network_add(self.req.context, network_values)
network_id = network_info.__dict__['id']
cluster_id = '737adb89-ee6f-4642-8196-9ee6926fbe50'
network_plane_name = 'physnet1'
session = api.get_session()
distribution_ip1 = api.according_to_cidr_distribution_ip(
cluster_id, network_plane_name, session)
self.assertEqual('112.18.1.2', distribution_ip1)
def test_get_network_ip_range(self):
network_values = {
'cluster_id': '737adb89-ee6f-4642-8196-9ee6926fbe50',
'cidr': '112.18.1.2/25',
'gateway': '112.18.1.1',
'ip_ranges': str(ip_ranges),
'name': 'physnet1',
'segmentation_type': 'vxlan',
'physnet_name': 'physnet_enp2s0',
'type': 'default',
'network_type': 'DATAPLANE',
}
network_info = api.network_add(self.req.context, network_values)
network_id = network_info.__dict__['id']
ip_ranges_sorted = api.get_network_ip_range(
self.req.context, network_id)
actual_ip_ranges = \
[(u'112.18.1.2', u'112.18.1.5', u'112.18.1.1/24', u'112.18.1.2'),
(u'112.18.1.15', u'112.18.1.15', u'112.18.1.1/24', u'112.18.1.1')]
self.assertEqual(actual_ip_ranges, ip_ranges_sorted)
def test_network_get_all(self):
network_values = {
'cluster_id': '737adb89-ee6f-4642-8196-9ee6926fbe50',
'cidr': '112.18.1.2/25',
'gateway': '112.18.1.1',
'ip_ranges': str(ip_ranges),
'name': 'physnet1',
'segmentation_type': 'vxlan',
'physnet_name': 'physnet_enp2s0',
'type': 'default',
'network_type': 'DATAPLANE',
}
network_info = api.network_add(self.req.context, network_values)
networks = api.network_get_all(self.req.context)
self.assertEqual(network_values['cluster_id'],
networks[0]['cluster_id'])
self.assertEqual(network_values['cidr'], networks[0]['cidr'])
def test__network_update(self):
network_values = {
'cluster_id': '737adb89-ee6f-4642-8196-9ee6926fbe50',
'cidr': '112.18.1.2/25',
'gateway': '112.18.1.1',
'ip_ranges': str(ip_ranges),
'name': 'physnet1',
'segmentation_type': 'vxlan',
'physnet_name': 'physnet_enp2s0',
'type': 'default',
'network_type': 'DATAPLANE',
}
network_info = api.network_add(self.req.context, network_values)
network_id = network_info.__dict__['id']
update_info = {'cidr': '112.18.1.2/24',
'gateway': '112.18.1.10',
'ip_ranges': str(ip_ranges)}
update_networks = \
api._network_update(self.req.context, update_info, network_id)
self.assertEqual(update_info['cidr'], update_networks['cidr'])