2 # -*- coding: utf-8 -*-
5 # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
6 # This file is part of openvim
9 # Licensed under the Apache License, Version 2.0 (the "License"); you may
10 # not use this file except in compliance with the License. You may obtain
11 # a copy of the License at
13 # http://www.apache.org/licenses/LICENSE-2.0
15 # Unless required by applicable law or agreed to in writing, software
16 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
17 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
18 # License for the specific language governing permissions and limitations
21 # For those usages not covered by the Apache License, Version 2.0 please
22 # contact with: nfvlabs@tid.es
26 This is the thread for the http server North API.
27 Two thread will be launched, with normal and administrative permissions.
30 __author__
= "Alfonso Tierno, Leonardo Mirabal"
31 __date__
= "$06-Feb-2017 12:07:15$"
32 __version__
= "0.5.10-r526"
33 version_date
= "Apr 2017"
34 database_version
= "0.17" #expected database schema version
41 from netaddr
import IPNetwork
42 from jsonschema
import validate
as js_v
, exceptions
as js_e
43 import host_thread
as ht
44 import dhcp_thread
as dt
45 import openflow_thread
as oft
49 HTTP_Bad_Request
= 400
50 HTTP_Unauthorized
= 401
53 HTTP_Method_Not_Allowed
= 405
54 HTTP_Not_Acceptable
= 406
55 HTTP_Request_Timeout
= 408
57 HTTP_Service_Unavailable
= 503
58 HTTP_Internal_Server_Error
= 500
61 def convert_boolean(data
, items
):
62 '''Check recursively the content of data, and if there is an key contained in items, convert value from string to boolean
63 It assumes that bandwidth is well formed
65 'data': dictionary bottle.FormsDict variable to be checked. None or empty is consideted valid
66 'items': tuple of keys to convert
70 if type(data
) is dict:
72 if type(data
[k
]) is dict or type(data
[k
]) is tuple or type(data
[k
]) is list:
73 convert_boolean(data
[k
], items
)
75 if type(data
[k
]) is str:
76 if data
[k
] == "false":
78 elif data
[k
] == "true":
80 if type(data
) is tuple or type(data
) is list:
82 if type(k
) is dict or type(k
) is tuple or type(k
) is list:
83 convert_boolean(k
, items
)
87 class ovimException(Exception):
88 def __init__(self
, message
, http_code
=HTTP_Bad_Request
):
89 self
.http_code
= http_code
90 Exception.__init
__(self
, message
)
94 running_info
= {} #TODO OVIM move the info of running threads from config_dic to this static variable
97 def __init__(self
, configuration
):
98 self
.config
= configuration
99 self
.logger_name
= configuration
.get("logger_name", "openvim")
100 self
.logger
= logging
.getLogger(self
.logger_name
)
102 self
.db
= self
._create
_database
_connection
()
105 self
.of_test_mode
= False
107 def _create_database_connection(self
):
108 db
= vim_db
.vim_db((self
.config
["network_vlan_range_start"], self
.config
["network_vlan_range_end"]),
109 self
.logger_name
+ ".db", self
.config
.get('log_level_db'))
110 if db
.connect(self
.config
['db_host'], self
.config
['db_user'], self
.config
['db_passwd'],
111 self
.config
['db_name']) == -1:
112 # self.logger.error("Cannot connect to database %s at %s@%s", self.config['db_name'], self.config['db_user'],
113 # self.config['db_host'])
114 raise ovimException("Cannot connect to database {} at {}@{}".format(self
.config
['db_name'],
115 self
.config
['db_user'],
116 self
.config
['db_host']) )
124 def get_version_date():
128 def get_database_version():
129 return database_version
132 def _check_dhcp_data_integrity(network
):
134 Check if all dhcp parameter for anet are valid, if not will be calculated from cidr value
135 :param network: list with user nets paramters
138 if "cidr" in network
:
139 cidr
= network
["cidr"]
140 ip_tools
= IPNetwork(cidr
)
141 cidr_len
= ip_tools
.prefixlen
145 ips
= IPNetwork(cidr
)
146 if "dhcp_first_ip" not in network
:
147 network
["dhcp_first_ip"] = str(ips
[2])
148 if "dhcp_last_ip" not in network
:
149 network
["dhcp_last_ip"] = str(ips
[-2])
150 if "gateway_ip" not in network
:
151 network
["gateway_ip"] = str(ips
[1])
158 def _check_valid_uuid(uuid
):
159 id_schema
= {"type": "string", "pattern": "^[a-fA-F0-9]{8}(-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}$"}
161 js_v(uuid
, id_schema
)
163 except js_e
.ValidationError
:
166 def start_service(self
):
171 global database_version
172 # if self.running_info:
173 # return #TODO service can be checked and rebuild broken threads
174 r
= self
.db
.get_db_version()
176 raise ovimException("DATABASE is not a VIM one or it is a '0.0' version. Try to upgrade to version '{}' with "\
177 "'./database_utils/migrate_vim_db.sh'".format(database_version
) )
178 elif r
[1] != database_version
:
179 raise ovimException("DATABASE wrong version '{}'. Try to upgrade/downgrade to version '{}' with "\
180 "'./database_utils/migrate_vim_db.sh'".format(r
[1], database_version
) )
181 self
.logger
.critical("Starting ovim server version: '{} {}' database version '{}'".format(
182 self
.get_version(), self
.get_version_date(), self
.get_database_version()))
183 # create database connection for openflow threads
184 self
.db_of
= self
._create
_database
_connection
()
185 self
.config
["db"] = self
.db_of
186 self
.db_lock
= threading
.Lock()
187 self
.config
["db_lock"] = self
.db_lock
189 self
.of_test_mode
= False if self
.config
['mode'] == 'normal' or self
.config
['mode'] == "OF only" else True
190 # precreate interfaces; [bridge:<host_bridge_name>, VLAN used at Host, uuid of network camping in this bridge,
193 self
.config
['dhcp_nets'] = []
194 self
.config
['bridge_nets'] = []
195 for bridge
, vlan_speed
in self
.config
["bridge_ifaces"].items():
196 # skip 'development_bridge'
197 if self
.config
['mode'] == 'development' and self
.config
['development_bridge'] == bridge
:
199 self
.config
['bridge_nets'].append([bridge
, vlan_speed
[0], vlan_speed
[1], None])
201 # check if this bridge is already used (present at database) for a network)
202 used_bridge_nets
= []
203 for brnet
in self
.config
['bridge_nets']:
204 r
, nets
= self
.db
.get_table(SELECT
=('uuid',), FROM
='nets', WHERE
={'provider': "bridge:" + brnet
[0]})
206 brnet
[3] = nets
[0]['uuid']
207 used_bridge_nets
.append(brnet
[0])
208 if self
.config
.get("dhcp_server"):
209 if brnet
[0] in self
.config
["dhcp_server"]["bridge_ifaces"]:
210 self
.config
['dhcp_nets'].append(nets
[0]['uuid'])
211 if len(used_bridge_nets
) > 0:
212 self
.logger
.info("found used bridge nets: " + ",".join(used_bridge_nets
))
213 # get nets used by dhcp
214 if self
.config
.get("dhcp_server"):
215 for net
in self
.config
["dhcp_server"].get("nets", ()):
216 r
, nets
= self
.db
.get_table(SELECT
=('uuid',), FROM
='nets', WHERE
={'name': net
})
218 self
.config
['dhcp_nets'].append(nets
[0]['uuid'])
221 self
._start
_ofc
_default
_task
()
223 # OFC per tenant in DB
224 self
._start
_of
_db
_tasks
()
226 # create dhcp_server thread
227 host_test_mode
= True if self
.config
['mode'] == 'test' or self
.config
['mode'] == "OF only" else False
228 dhcp_params
= self
.config
.get("dhcp_server")
230 thread
= dt
.dhcp_thread(dhcp_params
=dhcp_params
, test
=host_test_mode
, dhcp_nets
=self
.config
["dhcp_nets"],
231 db
=self
.db_of
, db_lock
=self
.db_lock
, logger_name
=self
.logger_name
+ ".dhcp",
232 debug
=self
.config
.get('log_level_of'))
234 self
.config
['dhcp_thread'] = thread
236 # Create one thread for each host
237 host_test_mode
= True if self
.config
['mode'] == 'test' or self
.config
['mode'] == "OF only" else False
238 host_develop_mode
= True if self
.config
['mode'] == 'development' else False
239 host_develop_bridge_iface
= self
.config
.get('development_bridge', None)
241 # get host list from data base before starting threads
242 r
, hosts
= self
.db
.get_table(SELECT
=('name', 'ip_name', 'user', 'uuid'), FROM
='hosts', WHERE
={'status': 'ok'})
244 raise ovimException("Cannot get hosts from database {}".format(hosts
))
246 self
.config
['host_threads'] = {}
248 host
['image_path'] = '/opt/VNF/images/openvim'
249 thread
= ht
.host_thread(name
=host
['name'], user
=host
['user'], host
=host
['ip_name'], db
=self
.db_of
,
250 db_lock
=self
.db_lock
, test
=host_test_mode
, image_path
=self
.config
['image_path'],
251 version
=self
.config
['version'], host_id
=host
['uuid'], develop_mode
=host_develop_mode
,
252 develop_bridge_iface
=host_develop_bridge_iface
,
253 logger_name
=self
.logger_name
+ ".host." + host
['name'],
254 debug
=self
.config
.get('log_level_host'))
256 self
.config
['host_threads'][host
['uuid']] = thread
258 # create ovs dhcp thread
259 result
, content
= self
.db
.get_table(FROM
='nets')
261 self
.logger
.error("http_get_ports Error %d %s", result
, content
)
262 raise ovimException(str(content
), -result
)
265 net_type
= net
['type']
266 if (net_type
== 'bridge_data' or net_type
== 'bridge_man') \
267 and net
["provider"][:4] == 'OVS:' and net
["enable_dhcp"] == "true":
268 self
.launch_dhcp_server(net
['vlan'],
269 net
['dhcp_first_ip'],
274 def _start_of_db_tasks(self
):
276 Start ofc task for existing ofcs in database
281 ofcs
= self
.get_of_controllers()
284 of_conn
= self
._load
_of
_module
(ofc
)
285 # create ofc thread per of controller
286 self
._create
_ofc
_task
(ofc
['uuid'], ofc
['dpid'], of_conn
)
288 def _create_ofc_task(self
, ofc_uuid
, dpid
, of_conn
):
290 Create an ofc thread for handle each sdn controllers
291 :param ofc_uuid: sdn controller uuid
292 :param dpid: sdn controller dpid
293 :param of_conn: OF_conn module
296 if 'ofcs_thread' not in self
.config
and 'ofcs_thread_dpid' not in self
.config
:
298 ofcs_thread_dpid
= []
300 ofcs_threads
= self
.config
['ofcs_thread']
301 ofcs_thread_dpid
= self
.config
['ofcs_thread_dpid']
303 if ofc_uuid
not in ofcs_threads
:
304 ofc_thread
= self
._create
_ofc
_thread
(of_conn
, ofc_uuid
)
305 if ofc_uuid
== "Default":
306 self
.config
['of_thread'] = ofc_thread
308 ofcs_threads
[ofc_uuid
] = ofc_thread
309 self
.config
['ofcs_thread'] = ofcs_threads
311 ofcs_thread_dpid
.append({dpid
: ofc_thread
})
312 self
.config
['ofcs_thread_dpid'] = ofcs_thread_dpid
314 def _start_ofc_default_task(self
):
316 Create default ofc thread
318 if 'of_controller' not in self
.config \
319 and 'of_controller_ip' not in self
.config \
320 and 'of_controller_port' not in self
.config \
321 and 'of_controller_dpid' not in self
.config
:
326 db_config
['ip'] = self
.config
.get('of_controller_ip')
327 db_config
['port'] = self
.config
.get('of_controller_port')
328 db_config
['dpid'] = self
.config
.get('of_controller_dpid')
329 db_config
['type'] = self
.config
.get('of_controller')
330 db_config
['user'] = self
.config
.get('of_user')
331 db_config
['password'] = self
.config
.get('of_password')
333 # create connector to the openflow controller
334 # load other parameters starting by of_ from config dict in a temporal dict
336 of_conn
= self
._load
_of
_module
(db_config
)
337 # create openflow thread
338 self
._create
_ofc
_task
("Default", db_config
['dpid'], of_conn
)
340 def _load_of_module(self
, db_config
):
342 import python module for each SDN controller supported
343 :param db_config: SDN dn information
347 raise ovimException("No module found it", HTTP_Internal_Server_Error
)
352 if self
.of_test_mode
:
353 return openflow_conn
.OfTestConnector({"name": db_config
['type'],
354 "dpid": db_config
['dpid'],
355 "of_debug": self
.config
['log_level_of']})
359 temp_dict
['of_ip'] = db_config
['ip']
360 temp_dict
['of_port'] = db_config
['port']
361 temp_dict
['of_dpid'] = db_config
['dpid']
362 temp_dict
['of_controller'] = db_config
['type']
363 temp_dict
['of_user'] = db_config
.get('user')
364 temp_dict
['of_password'] = db_config
.get('password')
366 temp_dict
['of_debug'] = self
.config
['log_level_of']
368 if temp_dict
['of_controller'] == 'opendaylight':
371 module
= temp_dict
['of_controller']
373 if module
not in ovim
.of_module
:
374 module_info
= imp
.find_module(module
)
375 of_conn_module
= imp
.load_module("OF_conn", *module_info
)
376 ovim
.of_module
[module
] = of_conn_module
378 of_conn_module
= ovim
.of_module
[module
]
381 return of_conn_module
.OF_conn(temp_dict
)
382 except Exception as e
:
383 self
.logger
.error("Cannot open the Openflow controller '%s': %s", type(e
).__name
__, str(e
))
384 if module_info
and module_info
[0]:
385 file.close(module_info
[0])
386 raise ovimException("Cannot open the Openflow controller '{}': '{}'".format(type(e
).__name
__, str(e
)),
387 HTTP_Internal_Server_Error
)
388 except (IOError, ImportError) as e
:
389 if module_info
and module_info
[0]:
390 file.close(module_info
[0])
391 self
.logger
.error("Cannot open openflow controller module '%s'; %s: %s; revise 'of_controller' "
392 "field of configuration file.", module
, type(e
).__name
__, str(e
))
393 raise ovimException("Cannot open openflow controller module '{}'; {}: {}; revise 'of_controller' "
394 "field of configuration file.".format(module
, type(e
).__name
__, str(e
)),
395 HTTP_Internal_Server_Error
)
397 def _create_ofc_thread(self
, of_conn
, ofc_uuid
="Default"):
399 Create and launch a of thread
402 # create openflow thread
404 #if 'of_controller_nets_with_same_vlan' in self.config:
405 # ofc_net_same_vlan = self.config['of_controller_nets_with_same_vlan']
407 # ofc_net_same_vlan = False
408 ofc_net_same_vlan
= False
410 thread
= oft
.openflow_thread(ofc_uuid
, of_conn
, of_test
=self
.of_test_mode
, db
=self
.db_of
, db_lock
=self
.db_lock
,
411 pmp_with_same_vlan
=ofc_net_same_vlan
, debug
=self
.config
['log_level_of'])
412 #r, c = thread.OF_connector.obtain_port_correspondence()
414 # raise ovimException("Cannot get openflow information %s", c)
418 def stop_service(self
):
419 threads
= self
.config
.get('host_threads', {})
420 if 'of_thread' in self
.config
:
421 threads
['of'] = (self
.config
['of_thread'])
422 if 'ofcs_thread' in self
.config
:
423 ofcs_thread
= self
.config
['ofcs_thread']
424 for ofc
in ofcs_thread
:
425 threads
[ofc
] = ofcs_thread
[ofc
]
427 if 'dhcp_thread' in self
.config
:
428 threads
['dhcp'] = (self
.config
['dhcp_thread'])
430 for thread
in threads
.values():
431 thread
.insert_task("exit")
432 for thread
in threads
.values():
435 def get_networks(self
, columns
=None, db_filter
={}, limit
=None):
437 Retreive networks available
438 :param columns: List with select query parameters
439 :param db_filter: List with where query parameters
440 :param limit: Query limit result
443 result
, content
= self
.db
.get_table(SELECT
=columns
, FROM
='nets', WHERE
=db_filter
, LIMIT
=limit
)
446 raise ovimException(str(content
), -result
)
448 convert_boolean(content
, ('shared', 'admin_state_up', 'enable_dhcp'))
452 def show_network(self
, network_id
, db_filter
={}):
454 Get network from DB by id
455 :param network_id: net Id
456 :param db_filter: List with where query parameters
461 raise ovimException("Not network id was not found")
462 db_filter
['uuid'] = network_id
464 result
, content
= self
.db
.get_table(FROM
='nets', WHERE
=db_filter
, LIMIT
=100)
467 raise ovimException(str(content
), -result
)
469 raise ovimException("show_network network '%s' not found" % network_id
, -result
)
471 convert_boolean(content
, ('shared', 'admin_state_up', 'enable_dhcp'))
473 result
, ports
= self
.db
.get_table(FROM
='ports', SELECT
=('uuid as port_id',),
474 WHERE
={'net_id': network_id
}, LIMIT
=100)
476 content
[0]['ports'] = ports
478 convert_boolean(content
, ('shared', 'admin_state_up', 'enable_dhcp'))
481 def new_network(self
, network
):
486 tenant_id
= network
.get('tenant_id')
489 result
, _
= self
.db
.get_table(FROM
='tenants', SELECT
=('uuid',), WHERE
={'uuid': tenant_id
, "enabled": True})
491 raise ovimException("set_network error, no tenant founded", -result
)
495 net_provider
= network
.get('provider')
496 net_type
= network
.get('type')
497 net_vlan
= network
.get("vlan")
498 net_bind_net
= network
.get("bind_net")
499 net_bind_type
= network
.get("bind_type")
500 name
= network
["name"]
502 # check if network name ends with :<vlan_tag> and network exist in order to make and automated bindning
503 vlan_index
= name
.rfind(":")
504 if not net_bind_net
and not net_bind_type
and vlan_index
> 1:
506 vlan_tag
= int(name
[vlan_index
+ 1:])
507 if not vlan_tag
and vlan_tag
< 4096:
508 net_bind_net
= name
[:vlan_index
]
509 net_bind_type
= "vlan:" + name
[vlan_index
+ 1:]
514 # look for a valid net
515 if self
._check
_valid
_uuid
(net_bind_net
):
516 net_bind_key
= "uuid"
518 net_bind_key
= "name"
519 result
, content
= self
.db
.get_table(FROM
='nets', WHERE
={net_bind_key
: net_bind_net
})
521 raise ovimException(' getting nets from db ' + content
, HTTP_Internal_Server_Error
)
523 raise ovimException(" bind_net %s '%s'not found" % (net_bind_key
, net_bind_net
), HTTP_Bad_Request
)
525 raise ovimException(" more than one bind_net %s '%s' found, use uuid" % (net_bind_key
, net_bind_net
), HTTP_Bad_Request
)
526 network
["bind_net"] = content
[0]["uuid"]
529 if net_bind_type
[0:5] != "vlan:":
530 raise ovimException("bad format for 'bind_type', must be 'vlan:<tag>'", HTTP_Bad_Request
)
531 if int(net_bind_type
[5:]) > 4095 or int(net_bind_type
[5:]) <= 0:
532 raise ovimException("bad format for 'bind_type', must be 'vlan:<tag>' with a tag between 1 and 4095",
534 network
["bind_type"] = net_bind_type
537 if net_provider
[:9] == "openflow:":
539 if net_type
!= "ptp" and net_type
!= "data":
540 raise ovimException(" only 'ptp' or 'data' net types can be bound to 'openflow'",
546 if net_type
!= "bridge_man" and net_type
!= "bridge_data":
547 raise ovimException("Only 'bridge_man' or 'bridge_data' net types can be bound "
548 "to 'bridge', 'macvtap' or 'default", HTTP_Bad_Request
)
550 net_type
= 'bridge_man'
553 net_type
= 'bridge_man'
556 if net_provider
[:7] == 'bridge:':
557 # check it is one of the pre-provisioned bridges
558 bridge_net_name
= net_provider
[7:]
559 for brnet
in self
.config
['bridge_nets']:
560 if brnet
[0] == bridge_net_name
: # free
562 raise ovimException("invalid 'provider:physical', "
563 "bridge '%s' is already used" % bridge_net_name
, HTTP_Conflict
)
567 # if bridge_net==None:
568 # bottle.abort(HTTP_Bad_Request, "invalid 'provider:physical', bridge '%s' is not one of the
569 # provisioned 'bridge_ifaces' in the configuration file" % bridge_net_name)
572 elif self
.config
['network_type'] == 'bridge' and (net_type
== 'bridge_data' or net_type
== 'bridge_man'):
573 # look for a free precreated nets
574 for brnet
in self
.config
['bridge_nets']:
575 if not brnet
[3]: # free
577 if net_type
== 'bridge_man': # look for the smaller speed
578 if brnet
[2] < bridge_net
[2]:
580 else: # look for the larger speed
581 if brnet
[2] > bridge_net
[2]:
587 raise ovimException("Max limits of bridge networks reached. Future versions of VIM "
588 "will overcome this limit", HTTP_Bad_Request
)
590 self
.logger
.debug("using net " + bridge_net
)
591 net_provider
= "bridge:" + bridge_net
[0]
592 net_vlan
= bridge_net
[1]
593 elif net_type
== 'bridge_data' or net_type
== 'bridge_man' and self
.config
['network_type'] == 'ovs':
595 if not net_vlan
and (net_type
== "data" or net_type
== "ptp" or net_provider
== "OVS"):
596 net_vlan
= self
.db
.get_free_net_vlan()
598 raise ovimException("Error getting an available vlan", HTTP_Internal_Server_Error
)
599 if net_provider
== 'OVS':
600 net_provider
= 'OVS' + ":" + str(net_vlan
)
602 network
['provider'] = net_provider
603 network
['type'] = net_type
604 network
['vlan'] = net_vlan
605 dhcp_integrity
= True
606 if 'enable_dhcp' in network
and network
['enable_dhcp']:
607 dhcp_integrity
= self
._check
_dhcp
_data
_integrity
(network
)
609 result
, content
= self
.db
.new_row('nets', network
, True, True)
611 if result
>= 0 and dhcp_integrity
:
613 bridge_net
[3] = content
614 if self
.config
.get("dhcp_server") and self
.config
['network_type'] == 'bridge':
615 if network
["name"] in self
.config
["dhcp_server"].get("nets", ()):
616 self
.config
["dhcp_nets"].append(content
)
617 self
.logger
.debug("dhcp_server: add new net", content
)
618 elif not bridge_net
and bridge_net
[0] in self
.config
["dhcp_server"].get("bridge_ifaces", ()):
619 self
.config
["dhcp_nets"].append(content
)
620 self
.logger
.debug("dhcp_server: add new net", content
, content
)
623 raise ovimException("Error posting network", HTTP_Internal_Server_Error
)
624 # TODO kei change update->edit
626 def edit_network(self
, network_id
, network
):
628 Update entwork data byt id
631 # Look for the previous data
632 where_
= {'uuid': network_id
}
633 result
, network_old
= self
.db
.get_table(FROM
='nets', WHERE
=where_
)
635 raise ovimException("Error updating network %s" % network_old
, HTTP_Internal_Server_Error
)
637 raise ovimException('network %s not found' % network_id
, HTTP_Not_Found
)
639 nbports
, content
= self
.db
.get_table(FROM
='ports', SELECT
=('uuid as port_id',),
640 WHERE
={'net_id': network_id
}, LIMIT
=100)
642 raise ovimException("http_put_network_id error %d %s" % (result
, network_old
), HTTP_Internal_Server_Error
)
644 if 'type' in network
and network
['type'] != network_old
[0]['type']:
645 raise ovimException("Can not change type of network while having ports attached",
646 HTTP_Method_Not_Allowed
)
647 if 'vlan' in network
and network
['vlan'] != network_old
[0]['vlan']:
648 raise ovimException("Can not change vlan of network while having ports attached",
649 HTTP_Method_Not_Allowed
)
652 net_provider
= network
.get('provider', network_old
[0]['provider'])
653 net_type
= network
.get('type', network_old
[0]['type'])
654 net_bind_net
= network
.get("bind_net")
655 net_bind_type
= network
.get("bind_type")
657 # look for a valid net
658 if self
._check
_valid
_uuid
(net_bind_net
):
659 net_bind_key
= "uuid"
661 net_bind_key
= "name"
662 result
, content
= self
.db
.get_table(FROM
='nets', WHERE
={net_bind_key
: net_bind_net
})
664 raise ovimException('Getting nets from db ' + content
, HTTP_Internal_Server_Error
)
666 raise ovimException("bind_net %s '%s'not found" % (net_bind_key
, net_bind_net
), HTTP_Bad_Request
)
668 raise ovimException("More than one bind_net %s '%s' found, use uuid" % (net_bind_key
, net_bind_net
),
670 network
["bind_net"] = content
[0]["uuid"]
672 if net_bind_type
[0:5] != "vlan:":
673 raise ovimException("Bad format for 'bind_type', must be 'vlan:<tag>'", HTTP_Bad_Request
)
674 if int(net_bind_type
[5:]) > 4095 or int(net_bind_type
[5:]) <= 0:
675 raise ovimException("bad format for 'bind_type', must be 'vlan:<tag>' with a tag between 1 and 4095",
678 if net_provider
[:9] == "openflow:":
679 if net_type
!= "ptp" and net_type
!= "data":
680 raise ovimException("Only 'ptp' or 'data' net types can be bound to 'openflow'", HTTP_Bad_Request
)
682 if net_type
!= "bridge_man" and net_type
!= "bridge_data":
683 raise ovimException("Only 'bridge_man' or 'bridge_data' net types can be bound to "
684 "'bridge', 'macvtap' or 'default", HTTP_Bad_Request
)
686 # insert in data base
687 result
, content
= self
.db
.update_rows('nets', network
, WHERE
={'uuid': network_id
}, log
=True)
689 # if result > 0 and nbports>0 and 'admin_state_up' in network
690 # and network['admin_state_up'] != network_old[0]['admin_state_up']:
695 self
.net_update_ofc_thread(network_id
)
696 except ovimException
as e
:
697 raise ovimException("Error while launching openflow rules in network '{}' {}"
698 .format(network_id
, str(e
)), HTTP_Internal_Server_Error
)
699 except Exception as e
:
700 raise ovimException("Error while launching openflow rules in network '{}' {}"
701 .format(network_id
, str(e
)), HTTP_Internal_Server_Error
)
703 if self
.config
.get("dhcp_server"):
704 if network_id
in self
.config
["dhcp_nets"]:
705 self
.config
["dhcp_nets"].remove(network_id
)
706 if network
.get("name", network_old
[0]["name"]) in self
.config
["dhcp_server"].get("nets", ()):
707 self
.config
["dhcp_nets"].append(network_id
)
709 net_bind
= network
.get("bind_type", network_old
[0]["bind_type"])
710 if net_bind
and net_bind
and net_bind
[:7] == "bridge:" and net_bind
[7:] in self
.config
["dhcp_server"].get(
711 "bridge_ifaces", ()):
712 self
.config
["dhcp_nets"].append(network_id
)
715 raise ovimException(content
, -result
)
717 def delete_network(self
, network_id
):
719 Delete network by network id
720 :param network_id: network id
724 # delete from the data base
725 result
, content
= self
.db
.delete_row('nets', network_id
)
728 raise ovimException("Network %s not found " % network_id
, HTTP_Not_Found
)
730 for brnet
in self
.config
['bridge_nets']:
731 if brnet
[3] == network_id
:
734 if self
.config
.get("dhcp_server") and network_id
in self
.config
["dhcp_nets"]:
735 self
.config
["dhcp_nets"].remove(network_id
)
738 raise ovimException("Error deleting network %s" % network_id
, HTTP_Internal_Server_Error
)
740 def get_openflow_rules(self
, network_id
=None):
742 Get openflow id from DB
743 :param network_id: Network id, if none all networks will be retrieved
744 :return: Return a list with Openflow rules per net
750 where_
= {"net_id": network_id
}
751 result
, content
= self
.db
.get_table(
752 SELECT
=("name", "net_id", "ofc_id", "priority", "vlan_id", "ingress_port", "src_mac", "dst_mac", "actions"),
753 WHERE
=where_
, FROM
='of_flows')
756 raise ovimException(str(content
), -result
)
759 def edit_openflow_rules(self
, network_id
=None):
762 To make actions over the net. The action is to reinstall the openflow rules
763 network_id can be 'all'
764 :param network_id: Network id, if none all networks will be retrieved
765 :return : Number of nets updated
772 where_
= {"uuid": network_id
}
773 result
, content
= self
.db
.get_table(SELECT
=("uuid", "type"), WHERE
=where_
, FROM
='nets')
776 raise ovimException(str(content
), -result
)
779 if net
["type"] != "ptp" and net
["type"] != "data":
784 self
.net_update_ofc_thread(net
['uuid'])
785 except ovimException
as e
:
786 raise ovimException("Error updating network'{}' {}".format(net
['uuid'], str(e
)),
787 HTTP_Internal_Server_Error
)
788 except Exception as e
:
789 raise ovimException("Error updating network '{}' {}".format(net
['uuid'], str(e
)),
790 HTTP_Internal_Server_Error
)
794 def delete_openflow_rules(self
, ofc_id
=None):
796 To make actions over the net. The action is to delete ALL openflow rules
797 :return: return operation result
801 if 'Default' in self
.config
['ofcs_thread']:
802 r
, c
= self
.config
['ofcs_thread']['Default'].insert_task("clear-all")
804 raise ovimException("Default Openflow controller not not running", HTTP_Not_Found
)
806 elif ofc_id
in self
.config
['ofcs_thread']:
807 r
, c
= self
.config
['ofcs_thread'][ofc_id
].insert_task("clear-all")
811 raise ovimException(str(c
), -r
)
813 raise ovimException("Openflow controller not found with ofc_id={}".format(ofc_id
), HTTP_Not_Found
)
816 def get_openflow_ports(self
, ofc_id
=None):
818 Obtain switch ports names of openflow controller
819 :return: Return flow ports in DB
822 if 'Default' in self
.config
['ofcs_thread']:
823 conn
= self
.config
['ofcs_thread']['Default'].OF_connector
825 raise ovimException("Default Openflow controller not not running", HTTP_Not_Found
)
827 if ofc_id
in self
.config
['ofcs_thread']:
828 conn
= self
.config
['ofcs_thread'][ofc_id
].OF_connector
830 raise ovimException("Openflow controller not found with ofc_id={}".format(ofc_id
), HTTP_Not_Found
)
833 def get_ports(self
, columns
=None, filter={}, limit
=None):
834 # result, content = my.db.get_ports(where_)
835 result
, content
= self
.db
.get_table(SELECT
=columns
, WHERE
=filter, FROM
='ports', LIMIT
=limit
)
837 self
.logger
.error("http_get_ports Error %d %s", result
, content
)
838 raise ovimException(str(content
), -result
)
840 convert_boolean(content
, ('admin_state_up',))
843 def new_port(self
, port_data
):
844 port_data
['type'] = 'external'
845 if port_data
.get('net_id'):
846 # check that new net has the correct type
847 result
, new_net
= self
.db
.check_target_net(port_data
['net_id'], None, 'external')
849 raise ovimException(str(new_net
), -result
)
850 # insert in data base
851 result
, uuid
= self
.db
.new_row('ports', port_data
, True, True)
853 if 'net_id' in port_data
:
855 self
.net_update_ofc_thread(port_data
['net_id'])
856 except ovimException
as e
:
857 raise ovimException("Cannot insert a task for updating network '{}' {}"
858 .format(port_data
['net_id'], str(e
)), HTTP_Internal_Server_Error
)
859 except Exception as e
:
860 raise ovimException("Cannot insert a task for updating network '{}' {}"
861 .format(port_data
['net_id'], str(e
)), HTTP_Internal_Server_Error
)
865 raise ovimException(str(uuid
), -result
)
867 def new_external_port(self
, port_data
):
869 Create new external port and check port mapping correspondence
870 :param port_data: port_data = {
871 'region': 'datacenter region',
872 'compute_node': 'compute node id',
873 'pci': 'pci port address',
876 'tenant_id': 'tenant id',
879 'ip_address': 'ip address - optional'}
883 port_data
['type'] = 'external'
885 if port_data
.get('net_id'):
886 # check that new net has the correct type
887 result
, new_net
= self
.db
.check_target_net(port_data
['net_id'], None, 'external')
889 raise ovimException(str(new_net
), -result
)
890 # insert in data base
893 if port_data
.get('region'):
894 db_filter
['region'] = port_data
['region']
895 if port_data
.get('pci'):
896 db_filter
['pci'] = port_data
['pci']
897 if port_data
.get('compute_node'):
898 db_filter
['compute_node'] = port_data
['compute_node']
900 columns
= ['ofc_id', 'switch_dpid', 'switch_port', 'switch_mac', 'pci']
901 port_mapping_data
= self
.get_of_port_mappings(columns
, db_filter
)
903 if not len(port_mapping_data
):
904 raise ovimException("No port mapping founded for '{}'".format(str(db_filter
)),
906 elif len(port_mapping_data
) > 1:
907 raise ovimException("Wrong port data was given, please check pci, region & compute id data",
910 port_data
['ofc_id'] = port_mapping_data
[0]['ofc_id']
911 port_data
['switch_dpid'] = port_mapping_data
[0]['switch_dpid']
912 port_data
['switch_port'] = port_mapping_data
[0]['switch_port']
913 port_data
['switch_mac'] = port_mapping_data
[0]['switch_mac']
915 # remove from compute_node, region and pci of_port_data to adapt to 'ports' structure
916 if 'region' in port_data
:
917 del port_data
['region']
918 if 'pci' in port_data
:
920 if 'compute_node' in port_data
:
921 del port_data
['compute_node']
923 result
, uuid
= self
.db
.new_row('ports', port_data
, True, True)
926 self
.net_update_ofc_thread(port_data
['net_id'], port_data
['ofc_id'])
927 except ovimException
as e
:
928 raise ovimException("Cannot insert a task for updating network '{}' {}".
929 format(port_data
['net_id'], str(e
)), HTTP_Internal_Server_Error
)
930 except Exception as e
:
931 raise ovimException("Cannot insert a task for updating network '{}' {}"
932 .format(port_data
['net_id'], e
), HTTP_Internal_Server_Error
)
935 raise ovimException(str(uuid
), -result
)
937 def net_update_ofc_thread(self
, net_id
, ofc_id
=None, switch_dpid
=None):
939 Insert a update net task by net id or ofc_id for each ofc thread
940 :param net_id: network id
941 :param ofc_id: openflow controller id
942 :param switch_dpid: switch dpid
946 raise ovimException("No net_id received", HTTP_Internal_Server_Error
)
949 c
= 'No valid ofc_id or switch_dpid received'
952 ports
= self
.get_ports(filter={"net_id": net_id
})
954 port_ofc_id
= port
.get('ofc_id', None)
956 ofc_id
= port
['ofc_id']
957 switch_dpid
= port
['switch_dpid']
959 #TODO if not ofc_id: look at database table ofcs
962 # If no ofc_id found it, default ofc_id is used.
963 if not ofc_id
and not switch_dpid
:
966 if ofc_id
and ofc_id
in self
.config
['ofcs_thread']:
967 r
, c
= self
.config
['ofcs_thread'][ofc_id
].insert_task("update-net", net_id
)
970 ofcs_dpid_list
= self
.config
['ofcs_thread_dpid']
971 for ofc_t
in ofcs_dpid_list
:
972 if switch_dpid
in ofc_t
:
973 r
, c
= ofc_t
[switch_dpid
].insert_task("update-net", net_id
)
976 message
= "Cannot insert a task for updating network '{}', {}".format(net_id
, c
)
977 self
.logger
.error(message
)
978 raise ovimException(message
, HTTP_Internal_Server_Error
)
980 def delete_port(self
, port_id
):
981 # Look for the previous port data
982 result
, ports
= self
.db
.get_table(WHERE
={'uuid': port_id
, "type": "external"}, FROM
='ports')
984 raise ovimException("Cannot get port info from database: {}".format(ports
), http_code
=-result
)
985 # delete from the data base
986 result
, content
= self
.db
.delete_row('ports', port_id
)
988 raise ovimException("External port '{}' not found".format(port_id
), http_code
=HTTP_Not_Found
)
990 raise ovimException("Cannot delete port from database: {}".format(content
), http_code
=-result
)
992 network
= ports
[0].get('net_id', None)
997 self
.net_update_ofc_thread(network
, ofc_id
=ports
[0]["ofc_id"], switch_dpid
=ports
[0]["switch_dpid"])
998 except ovimException
as e
:
999 raise ovimException("Cannot insert a task for delete network '{}' {}".format(network
, str(e
)),
1000 HTTP_Internal_Server_Error
)
1001 except Exception as e
:
1002 raise ovimException("Cannot insert a task for delete network '{}' {}".format(network
, str(e
)),
1003 HTTP_Internal_Server_Error
)
1007 def edit_port(self
, port_id
, port_data
, admin
=True):
1008 # Look for the previous port data
1009 result
, content
= self
.db
.get_table(FROM
="ports", WHERE
={'uuid': port_id
})
1011 raise ovimException("Cannot get port info from database: {}".format(content
), http_code
=-result
)
1013 raise ovimException("Port '{}' not found".format(port_id
), http_code
=HTTP_Not_Found
)
1018 if 'net_id' in port_data
:
1020 old_net
= port
.get('net_id', None)
1021 new_net
= port_data
['net_id']
1022 if old_net
!= new_net
:
1025 nets
.append(new_net
) # put first the new net, so that new openflow rules are created before removing the old ones
1027 nets
.append(old_net
)
1028 if port
['type'] == 'instance:bridge' or port
['type'] == 'instance:ovs':
1029 raise ovimException("bridge interfaces cannot be attached to a different net", http_code
=HTTP_Forbidden
)
1030 elif port
['type'] == 'external' and not admin
:
1031 raise ovimException("Needed admin privileges",http_code
=HTTP_Unauthorized
)
1033 # check that new net has the correct type
1034 result
, new_net_dict
= self
.db
.check_target_net(new_net
, None, port
['type'])
1036 raise ovimException("Error {}".format(new_net_dict
), http_code
=HTTP_Conflict
)
1037 # change VLAN for SR-IOV ports
1038 if result
>= 0 and port
["type"] == "instance:data" and port
["model"] == "VF": # TODO consider also VFnotShared
1040 port_data
["vlan"] = None
1042 port_data
["vlan"] = new_net_dict
["vlan"]
1043 # get host where this VM is allocated
1044 result
, content
= self
.db
.get_table(FROM
="instances", WHERE
={"uuid": port
["instance_id"]})
1046 host_id
= content
[0]["host_id"]
1048 # insert in data base
1050 result
, content
= self
.db
.update_rows('ports', port_data
, WHERE
={'uuid': port_id
}, log
=False)
1051 port
.update(port_data
)
1053 # Insert task to complete actions
1057 self
.net_update_ofc_thread(net_id
, port
["ofc_id"], switch_dpid
=port
["switch_dpid"])
1058 except ovimException
as e
:
1059 raise ovimException("Error updating network'{}' {}".format(net_id
, str(e
)),
1060 HTTP_Internal_Server_Error
)
1061 except Exception as e
:
1062 raise ovimException("Error updating network '{}' {}".format(net_id
, str(e
)),
1063 HTTP_Internal_Server_Error
)
1066 r
, v
= self
.config
['host_threads'][host_id
].insert_task("edit-iface", port_id
, old_net
, new_net
)
1068 self
.logger
.error("Error updating network '{}' {}".format(r
,v
))
1069 # TODO Do something if fails
1073 raise ovimException("Error {}".format(content
), http_code
=-result
)
1075 def new_of_controller(self
, ofc_data
):
1077 Create a new openflow controller into DB
1078 :param ofc_data: Dict openflow controller data
1079 :return: openflow controller dpid
1082 result
, ofc_uuid
= self
.db
.new_row('ofcs', ofc_data
, True, True)
1084 raise ovimException("New ofc Error %s" % ofc_uuid
, HTTP_Internal_Server_Error
)
1086 ofc_data
['uuid'] = ofc_uuid
1087 of_conn
= self
._load
_of
_module
(ofc_data
)
1088 self
._create
_ofc
_task
(ofc_uuid
, ofc_data
['dpid'], of_conn
)
1092 def edit_of_controller(self
, of_id
, ofc_data
):
1094 Edit an openflow controller entry from DB
1098 raise ovimException("No data received during uptade OF contorller", http_code
=HTTP_Internal_Server_Error
)
1100 old_of_controller
= self
.show_of_controller(of_id
)
1102 if old_of_controller
:
1103 result
, content
= self
.db
.update_rows('ofcs', ofc_data
, WHERE
={'uuid': of_id
}, log
=False)
1107 raise ovimException("Error uptating OF contorller with uuid {}".format(of_id
),
1110 raise ovimException("Error uptating OF contorller with uuid {}".format(of_id
),
1111 http_code
=HTTP_Internal_Server_Error
)
1113 def delete_of_controller(self
, of_id
):
1115 Delete an openflow controller from DB.
1116 :param of_id: openflow controller dpid
1120 ofc
= self
.show_of_controller(of_id
)
1122 result
, content
= self
.db
.delete_row("ofcs", of_id
)
1124 raise ovimException("Cannot delete ofc from database: {}".format(content
), http_code
=-result
)
1126 raise ovimException("ofc {} not found ".format(content
), http_code
=HTTP_Not_Found
)
1128 ofc_thread
= self
.config
['ofcs_thread'][of_id
]
1129 del self
.config
['ofcs_thread'][of_id
]
1130 for ofc_th
in self
.config
['ofcs_thread_dpid']:
1131 if ofc
['dpid'] in ofc_th
:
1132 self
.config
['ofcs_thread_dpid'].remove(ofc_th
)
1134 ofc_thread
.insert_task("exit")
1139 def show_of_controller(self
, uuid
):
1141 Show an openflow controller by dpid from DB.
1142 :param db_filter: List with where query parameters
1146 result
, content
= self
.db
.get_table(FROM
='ofcs', WHERE
={"uuid": uuid
}, LIMIT
=100)
1149 raise ovimException("Openflow controller with uuid '{}' not found".format(uuid
),
1150 http_code
=HTTP_Not_Found
)
1152 raise ovimException("Openflow controller with uuid '{}' error".format(uuid
),
1153 http_code
=HTTP_Internal_Server_Error
)
1156 def get_of_controllers(self
, columns
=None, db_filter
={}, limit
=None):
1158 Show an openflow controllers from DB.
1159 :param columns: List with SELECT query parameters
1160 :param db_filter: List with where query parameters
1161 :param limit: result Limit
1164 result
, content
= self
.db
.get_table(SELECT
=columns
, FROM
='ofcs', WHERE
=db_filter
, LIMIT
=limit
)
1167 raise ovimException(str(content
), -result
)
1171 def get_tenants(self
, columns
=None, db_filter
={}, limit
=None):
1173 Retrieve tenant list from DB
1174 :param columns: List with SELECT query parameters
1175 :param db_filter: List with where query parameters
1176 :param limit: result limit
1179 result
, content
= self
.db
.get_table(FROM
='tenants', SELECT
=columns
, WHERE
=db_filter
, LIMIT
=limit
)
1181 raise ovimException('get_tenatns Error {}'.format(str(content
)), -result
)
1183 convert_boolean(content
, ('enabled',))
1186 def show_tenant_id(self
, tenant_id
):
1188 Get tenant from DB by id
1189 :param tenant_id: tenant id
1192 result
, content
= self
.db
.get_table(FROM
='tenants', SELECT
=('uuid', 'name', 'description', 'enabled'),
1193 WHERE
={"uuid": tenant_id
})
1195 raise ovimException(str(content
), -result
)
1197 raise ovimException("tenant with uuid='{}' not found".format(tenant_id
), HTTP_Not_Found
)
1199 convert_boolean(content
, ('enabled',))
1202 def new_tentant(self
, tenant
):
1204 Create a tenant and store in DB
1205 :param tenant: Dictionary with tenant data
1206 :return: the uuid of created tenant. Raise exception upon error
1209 # insert in data base
1210 result
, tenant_uuid
= self
.db
.new_tenant(tenant
)
1215 raise ovimException(str(tenant_uuid
), -result
)
1217 def delete_tentant(self
, tenant_id
):
1219 Delete a tenant from the database.
1220 :param tenant_id: Tenant id
1221 :return: delete tenant id
1225 r
, tenants_flavors
= self
.db
.get_table(FROM
='tenants_flavors', SELECT
=('flavor_id', 'tenant_id'),
1226 WHERE
={'tenant_id': tenant_id
})
1228 tenants_flavors
= ()
1229 r
, tenants_images
= self
.db
.get_table(FROM
='tenants_images', SELECT
=('image_id', 'tenant_id'),
1230 WHERE
={'tenant_id': tenant_id
})
1234 result
, content
= self
.db
.delete_row('tenants', tenant_id
)
1236 raise ovimException("tenant '%s' not found" % tenant_id
, HTTP_Not_Found
)
1238 for flavor
in tenants_flavors
:
1239 self
.db
.delete_row_by_key("flavors", "uuid", flavor
['flavor_id'])
1240 for image
in tenants_images
:
1241 self
.db
.delete_row_by_key("images", "uuid", image
['image_id'])
1244 raise ovimException("Error deleting tenant '%s' " % tenant_id
, HTTP_Internal_Server_Error
)
1246 def edit_tenant(self
, tenant_id
, tenant_data
):
1248 Update a tenant data identified by tenant id
1249 :param tenant_id: tenant id
1250 :param tenant_data: Dictionary with tenant data
1254 # Look for the previous data
1255 result
, tenant_data_old
= self
.db
.get_table(FROM
='tenants', WHERE
={'uuid': tenant_id
})
1257 raise ovimException("Error updating tenant with uuid='{}': {}".format(tenant_id
, tenant_data_old
),
1258 HTTP_Internal_Server_Error
)
1260 raise ovimException("tenant with uuid='{}' not found".format(tenant_id
), HTTP_Not_Found
)
1262 # insert in data base
1263 result
, content
= self
.db
.update_rows('tenants', tenant_data
, WHERE
={'uuid': tenant_id
}, log
=True)
1267 raise ovimException(str(content
), -result
)
1269 def set_of_port_mapping(self
, of_maps
, ofc_id
=None, switch_dpid
=None, region
=None):
1271 Create new port mapping entry
1272 :param of_maps: List with port mapping information
1273 # maps =[{"ofc_id": <ofc_id>,"region": datacenter region,"compute_node": compute uuid,"pci": pci adress,
1274 "switch_dpid": swith dpid,"switch_port": port name,"switch_mac": mac}]
1275 :param ofc_id: ofc id
1276 :param switch_dpid: switch dpid
1277 :param region: datacenter region id
1283 map['ofc_id'] = ofc_id
1285 map['switch_dpid'] = switch_dpid
1287 map['region'] = region
1289 for of_map
in of_maps
:
1290 result
, uuid
= self
.db
.new_row('of_port_mappings', of_map
, True)
1292 of_map
["uuid"] = uuid
1294 raise ovimException(str(uuid
), -result
)
1297 def clear_of_port_mapping(self
, db_filter
={}):
1299 Clear port mapping filtering using db_filter dict
1300 :param db_filter: Parameter to filter during remove process
1303 result
, content
= self
.db
.delete_row_by_dict(FROM
='of_port_mappings', WHERE
=db_filter
)
1308 raise ovimException("Error deleting of_port_mappings with filter='{}'".format(str(db_filter
)),
1309 HTTP_Internal_Server_Error
)
1311 def get_of_port_mappings(self
, column
=None, db_filter
=None, db_limit
=None):
1313 Retrive port mapping from DB
1318 result
, content
= self
.db
.get_table(SELECT
=column
, WHERE
=db_filter
, FROM
='of_port_mappings', LIMIT
=db_limit
)
1321 self
.logger
.error("get_of_port_mappings Error %d %s", result
, content
)
1322 raise ovimException(str(content
), -result
)
1326 def get_dhcp_controller(self
):
1328 Create an host_thread object for manage openvim controller and not create a thread for itself
1329 :return: dhcp_host openvim controller object
1332 if 'openvim_controller' in self
.config
['host_threads']:
1333 return self
.config
['host_threads']['openvim_controller']
1336 controller_ip
= self
.config
['ovs_controller_ip']
1337 ovs_controller_user
= self
.config
['ovs_controller_user']
1339 host_test_mode
= True if self
.config
['mode'] == 'test' or self
.config
['mode'] == "OF only" else False
1340 host_develop_mode
= True if self
.config
['mode'] == 'development' else False
1342 dhcp_host
= ht
.host_thread(name
='openvim_controller', user
=ovs_controller_user
, host
=controller_ip
,
1344 db_lock
=self
.db_lock
, test
=host_test_mode
,
1345 image_path
=self
.config
['image_path'], version
=self
.config
['version'],
1346 host_id
='openvim_controller', develop_mode
=host_develop_mode
,
1347 develop_bridge_iface
=bridge_ifaces
, logger_name
=self
.logger_name
+ ".host.controller",
1348 debug
=self
.config
.get('log_level_host'))
1350 self
.config
['host_threads']['openvim_controller'] = dhcp_host
1351 if not host_test_mode
:
1352 dhcp_host
.ssh_connect()
1355 def launch_dhcp_server(self
, vlan
, first_ip
, last_ip
, cidr
, gateway
):
1357 Launch a dhcpserver base on dnsmasq attached to the net base on vlan id across the the openvim computes
1358 :param vlan: vlan identifier
1359 :param first_ip: First dhcp range ip
1360 :param last_ip: Last dhcp range ip
1361 :param cidr: net cidr
1362 :param gateway: net gateway
1365 ip_tools
= IPNetwork(cidr
)
1366 dhcp_netmask
= str(ip_tools
.netmask
)
1367 ip_range
= [first_ip
, last_ip
]
1369 dhcp_path
= self
.config
['ovs_controller_file_path']
1371 controller_host
= self
.get_dhcp_controller()
1372 controller_host
.create_linux_bridge(vlan
)
1373 controller_host
.create_dhcp_interfaces(vlan
, first_ip
, dhcp_netmask
)
1374 controller_host
.launch_dhcp_server(vlan
, ip_range
, dhcp_netmask
, dhcp_path
, gateway
)
1376 if __name__
== "__main__":
1378 parser
= argparse
.ArgumentParser()
1379 parser
.add_argument("-v","--version", help="show ovim library version", action
="store_true")
1380 parser
.add_argument("--database-version", help="show required database version", action
="store_true")
1381 args
= parser
.parse_args()
1383 print ('openvimd version {} {}'.format(ovim
.get_version(), ovim
.get_version_date()))
1384 print ('(c) Copyright Telefonica')
1385 elif args
.database_version
:
1386 print ('required database version: {}'.format(ovim
.get_database_version()))