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 for base
in ("", "osm_openvim.", "lib_osm_openvim."):
376 pkg
= __import__(base
+ module
)
378 of_conn_module
= getattr(pkg
, module
)
381 ovim
.of_module
[module
] = of_conn_module
382 self
.logger
.debug("Module load from {}".format(base
+ module
))
384 except Exception as e
:
385 self
.logger
.warning("Module {} not found {}".format(base
+ module
, e
))
387 self
.logger
.error("Cannot open openflow controller module of type '%s'", module
)
388 raise ovimException("Cannot open openflow controller of type module '{}'"
389 "Revise it is installed".format(module
),
390 HTTP_Internal_Server_Error
)
392 of_conn_module
= ovim
.of_module
[module
]
393 return of_conn_module
.OF_conn(temp_dict
)
394 except Exception as e
:
395 self
.logger
.error("Cannot open the Openflow controller '%s': %s", type(e
).__name
__, str(e
))
396 raise ovimException("Cannot open the Openflow controller '{}': '{}'".format(type(e
).__name
__, str(e
)),
397 HTTP_Internal_Server_Error
)
399 def _create_ofc_thread(self
, of_conn
, ofc_uuid
="Default"):
401 Create and launch a of thread
404 # create openflow thread
406 #if 'of_controller_nets_with_same_vlan' in self.config:
407 # ofc_net_same_vlan = self.config['of_controller_nets_with_same_vlan']
409 # ofc_net_same_vlan = False
410 ofc_net_same_vlan
= False
412 thread
= oft
.openflow_thread(ofc_uuid
, of_conn
, of_test
=self
.of_test_mode
, db
=self
.db_of
, db_lock
=self
.db_lock
,
413 pmp_with_same_vlan
=ofc_net_same_vlan
, debug
=self
.config
['log_level_of'])
414 #r, c = thread.OF_connector.obtain_port_correspondence()
416 # raise ovimException("Cannot get openflow information %s", c)
420 def stop_service(self
):
421 threads
= self
.config
.get('host_threads', {})
422 if 'of_thread' in self
.config
:
423 threads
['of'] = (self
.config
['of_thread'])
424 if 'ofcs_thread' in self
.config
:
425 ofcs_thread
= self
.config
['ofcs_thread']
426 for ofc
in ofcs_thread
:
427 threads
[ofc
] = ofcs_thread
[ofc
]
429 if 'dhcp_thread' in self
.config
:
430 threads
['dhcp'] = (self
.config
['dhcp_thread'])
432 for thread
in threads
.values():
433 thread
.insert_task("exit")
434 for thread
in threads
.values():
437 def get_networks(self
, columns
=None, db_filter
={}, limit
=None):
439 Retreive networks available
440 :param columns: List with select query parameters
441 :param db_filter: List with where query parameters
442 :param limit: Query limit result
445 result
, content
= self
.db
.get_table(SELECT
=columns
, FROM
='nets', WHERE
=db_filter
, LIMIT
=limit
)
448 raise ovimException(str(content
), -result
)
450 convert_boolean(content
, ('shared', 'admin_state_up', 'enable_dhcp'))
454 def show_network(self
, network_id
, db_filter
={}):
456 Get network from DB by id
457 :param network_id: net Id
458 :param db_filter: List with where query parameters
463 raise ovimException("Not network id was not found")
464 db_filter
['uuid'] = network_id
466 result
, content
= self
.db
.get_table(FROM
='nets', WHERE
=db_filter
, LIMIT
=100)
469 raise ovimException(str(content
), -result
)
471 raise ovimException("show_network network '%s' not found" % network_id
, -result
)
473 convert_boolean(content
, ('shared', 'admin_state_up', 'enable_dhcp'))
475 result
, ports
= self
.db
.get_table(FROM
='ports', SELECT
=('uuid as port_id',),
476 WHERE
={'net_id': network_id
}, LIMIT
=100)
478 content
[0]['ports'] = ports
480 convert_boolean(content
, ('shared', 'admin_state_up', 'enable_dhcp'))
483 def new_network(self
, network
):
488 tenant_id
= network
.get('tenant_id')
491 result
, _
= self
.db
.get_table(FROM
='tenants', SELECT
=('uuid',), WHERE
={'uuid': tenant_id
, "enabled": True})
493 raise ovimException("set_network error, no tenant founded", -result
)
497 net_provider
= network
.get('provider')
498 net_type
= network
.get('type')
499 net_vlan
= network
.get("vlan")
500 net_bind_net
= network
.get("bind_net")
501 net_bind_type
= network
.get("bind_type")
502 name
= network
["name"]
504 # check if network name ends with :<vlan_tag> and network exist in order to make and automated bindning
505 vlan_index
= name
.rfind(":")
506 if not net_bind_net
and not net_bind_type
and vlan_index
> 1:
508 vlan_tag
= int(name
[vlan_index
+ 1:])
509 if not vlan_tag
and vlan_tag
< 4096:
510 net_bind_net
= name
[:vlan_index
]
511 net_bind_type
= "vlan:" + name
[vlan_index
+ 1:]
516 # look for a valid net
517 if self
._check
_valid
_uuid
(net_bind_net
):
518 net_bind_key
= "uuid"
520 net_bind_key
= "name"
521 result
, content
= self
.db
.get_table(FROM
='nets', WHERE
={net_bind_key
: net_bind_net
})
523 raise ovimException(' getting nets from db ' + content
, HTTP_Internal_Server_Error
)
525 raise ovimException(" bind_net %s '%s'not found" % (net_bind_key
, net_bind_net
), HTTP_Bad_Request
)
527 raise ovimException(" more than one bind_net %s '%s' found, use uuid" % (net_bind_key
, net_bind_net
), HTTP_Bad_Request
)
528 network
["bind_net"] = content
[0]["uuid"]
531 if net_bind_type
[0:5] != "vlan:":
532 raise ovimException("bad format for 'bind_type', must be 'vlan:<tag>'", HTTP_Bad_Request
)
533 if int(net_bind_type
[5:]) > 4095 or int(net_bind_type
[5:]) <= 0:
534 raise ovimException("bad format for 'bind_type', must be 'vlan:<tag>' with a tag between 1 and 4095",
536 network
["bind_type"] = net_bind_type
539 if net_provider
[:9] == "openflow:":
541 if net_type
!= "ptp" and net_type
!= "data":
542 raise ovimException(" only 'ptp' or 'data' net types can be bound to 'openflow'",
548 if net_type
!= "bridge_man" and net_type
!= "bridge_data":
549 raise ovimException("Only 'bridge_man' or 'bridge_data' net types can be bound "
550 "to 'bridge', 'macvtap' or 'default", HTTP_Bad_Request
)
552 net_type
= 'bridge_man'
555 net_type
= 'bridge_man'
558 if net_provider
[:7] == 'bridge:':
559 # check it is one of the pre-provisioned bridges
560 bridge_net_name
= net_provider
[7:]
561 for brnet
in self
.config
['bridge_nets']:
562 if brnet
[0] == bridge_net_name
: # free
564 raise ovimException("invalid 'provider:physical', "
565 "bridge '%s' is already used" % bridge_net_name
, HTTP_Conflict
)
569 # if bridge_net==None:
570 # bottle.abort(HTTP_Bad_Request, "invalid 'provider:physical', bridge '%s' is not one of the
571 # provisioned 'bridge_ifaces' in the configuration file" % bridge_net_name)
574 elif self
.config
['network_type'] == 'bridge' and (net_type
== 'bridge_data' or net_type
== 'bridge_man'):
575 # look for a free precreated nets
576 for brnet
in self
.config
['bridge_nets']:
577 if not brnet
[3]: # free
579 if net_type
== 'bridge_man': # look for the smaller speed
580 if brnet
[2] < bridge_net
[2]:
582 else: # look for the larger speed
583 if brnet
[2] > bridge_net
[2]:
589 raise ovimException("Max limits of bridge networks reached. Future versions of VIM "
590 "will overcome this limit", HTTP_Bad_Request
)
592 self
.logger
.debug("using net " + bridge_net
)
593 net_provider
= "bridge:" + bridge_net
[0]
594 net_vlan
= bridge_net
[1]
595 elif net_type
== 'bridge_data' or net_type
== 'bridge_man' and self
.config
['network_type'] == 'ovs':
597 if not net_vlan
and (net_type
== "data" or net_type
== "ptp" or net_provider
== "OVS"):
598 net_vlan
= self
.db
.get_free_net_vlan()
600 raise ovimException("Error getting an available vlan", HTTP_Internal_Server_Error
)
601 if net_provider
== 'OVS':
602 net_provider
= 'OVS' + ":" + str(net_vlan
)
604 network
['provider'] = net_provider
605 network
['type'] = net_type
606 network
['vlan'] = net_vlan
607 dhcp_integrity
= True
608 if 'enable_dhcp' in network
and network
['enable_dhcp']:
609 dhcp_integrity
= self
._check
_dhcp
_data
_integrity
(network
)
611 result
, content
= self
.db
.new_row('nets', network
, True, True)
613 if result
>= 0 and dhcp_integrity
:
615 bridge_net
[3] = content
616 if self
.config
.get("dhcp_server") and self
.config
['network_type'] == 'bridge':
617 if network
["name"] in self
.config
["dhcp_server"].get("nets", ()):
618 self
.config
["dhcp_nets"].append(content
)
619 self
.logger
.debug("dhcp_server: add new net", content
)
620 elif not bridge_net
and bridge_net
[0] in self
.config
["dhcp_server"].get("bridge_ifaces", ()):
621 self
.config
["dhcp_nets"].append(content
)
622 self
.logger
.debug("dhcp_server: add new net", content
, content
)
625 raise ovimException("Error posting network", HTTP_Internal_Server_Error
)
626 # TODO kei change update->edit
628 def edit_network(self
, network_id
, network
):
630 Update entwork data byt id
633 # Look for the previous data
634 where_
= {'uuid': network_id
}
635 result
, network_old
= self
.db
.get_table(FROM
='nets', WHERE
=where_
)
637 raise ovimException("Error updating network %s" % network_old
, HTTP_Internal_Server_Error
)
639 raise ovimException('network %s not found' % network_id
, HTTP_Not_Found
)
641 nbports
, content
= self
.db
.get_table(FROM
='ports', SELECT
=('uuid as port_id',),
642 WHERE
={'net_id': network_id
}, LIMIT
=100)
644 raise ovimException("http_put_network_id error %d %s" % (result
, network_old
), HTTP_Internal_Server_Error
)
646 if 'type' in network
and network
['type'] != network_old
[0]['type']:
647 raise ovimException("Can not change type of network while having ports attached",
648 HTTP_Method_Not_Allowed
)
649 if 'vlan' in network
and network
['vlan'] != network_old
[0]['vlan']:
650 raise ovimException("Can not change vlan of network while having ports attached",
651 HTTP_Method_Not_Allowed
)
654 net_provider
= network
.get('provider', network_old
[0]['provider'])
655 net_type
= network
.get('type', network_old
[0]['type'])
656 net_bind_net
= network
.get("bind_net")
657 net_bind_type
= network
.get("bind_type")
659 # look for a valid net
660 if self
._check
_valid
_uuid
(net_bind_net
):
661 net_bind_key
= "uuid"
663 net_bind_key
= "name"
664 result
, content
= self
.db
.get_table(FROM
='nets', WHERE
={net_bind_key
: net_bind_net
})
666 raise ovimException('Getting nets from db ' + content
, HTTP_Internal_Server_Error
)
668 raise ovimException("bind_net %s '%s'not found" % (net_bind_key
, net_bind_net
), HTTP_Bad_Request
)
670 raise ovimException("More than one bind_net %s '%s' found, use uuid" % (net_bind_key
, net_bind_net
),
672 network
["bind_net"] = content
[0]["uuid"]
674 if net_bind_type
[0:5] != "vlan:":
675 raise ovimException("Bad format for 'bind_type', must be 'vlan:<tag>'", HTTP_Bad_Request
)
676 if int(net_bind_type
[5:]) > 4095 or int(net_bind_type
[5:]) <= 0:
677 raise ovimException("bad format for 'bind_type', must be 'vlan:<tag>' with a tag between 1 and 4095",
680 if net_provider
[:9] == "openflow:":
681 if net_type
!= "ptp" and net_type
!= "data":
682 raise ovimException("Only 'ptp' or 'data' net types can be bound to 'openflow'", HTTP_Bad_Request
)
684 if net_type
!= "bridge_man" and net_type
!= "bridge_data":
685 raise ovimException("Only 'bridge_man' or 'bridge_data' net types can be bound to "
686 "'bridge', 'macvtap' or 'default", HTTP_Bad_Request
)
688 # insert in data base
689 result
, content
= self
.db
.update_rows('nets', network
, WHERE
={'uuid': network_id
}, log
=True)
691 # if result > 0 and nbports>0 and 'admin_state_up' in network
692 # and network['admin_state_up'] != network_old[0]['admin_state_up']:
697 self
.net_update_ofc_thread(network_id
)
698 except ovimException
as e
:
699 raise ovimException("Error while launching openflow rules in network '{}' {}"
700 .format(network_id
, str(e
)), HTTP_Internal_Server_Error
)
701 except Exception as e
:
702 raise ovimException("Error while launching openflow rules in network '{}' {}"
703 .format(network_id
, str(e
)), HTTP_Internal_Server_Error
)
705 if self
.config
.get("dhcp_server"):
706 if network_id
in self
.config
["dhcp_nets"]:
707 self
.config
["dhcp_nets"].remove(network_id
)
708 if network
.get("name", network_old
[0]["name"]) in self
.config
["dhcp_server"].get("nets", ()):
709 self
.config
["dhcp_nets"].append(network_id
)
711 net_bind
= network
.get("bind_type", network_old
[0]["bind_type"])
712 if net_bind
and net_bind
and net_bind
[:7] == "bridge:" and net_bind
[7:] in self
.config
["dhcp_server"].get(
713 "bridge_ifaces", ()):
714 self
.config
["dhcp_nets"].append(network_id
)
717 raise ovimException(content
, -result
)
719 def delete_network(self
, network_id
):
721 Delete network by network id
722 :param network_id: network id
726 # delete from the data base
727 result
, content
= self
.db
.delete_row('nets', network_id
)
730 raise ovimException("Network %s not found " % network_id
, HTTP_Not_Found
)
732 for brnet
in self
.config
['bridge_nets']:
733 if brnet
[3] == network_id
:
736 if self
.config
.get("dhcp_server") and network_id
in self
.config
["dhcp_nets"]:
737 self
.config
["dhcp_nets"].remove(network_id
)
740 raise ovimException("Error deleting network %s" % network_id
, HTTP_Internal_Server_Error
)
742 def get_openflow_rules(self
, network_id
=None):
744 Get openflow id from DB
745 :param network_id: Network id, if none all networks will be retrieved
746 :return: Return a list with Openflow rules per net
752 where_
= {"net_id": network_id
}
753 result
, content
= self
.db
.get_table(
754 SELECT
=("name", "net_id", "ofc_id", "priority", "vlan_id", "ingress_port", "src_mac", "dst_mac", "actions"),
755 WHERE
=where_
, FROM
='of_flows')
758 raise ovimException(str(content
), -result
)
761 def edit_openflow_rules(self
, network_id
=None):
764 To make actions over the net. The action is to reinstall the openflow rules
765 network_id can be 'all'
766 :param network_id: Network id, if none all networks will be retrieved
767 :return : Number of nets updated
774 where_
= {"uuid": network_id
}
775 result
, content
= self
.db
.get_table(SELECT
=("uuid", "type"), WHERE
=where_
, FROM
='nets')
778 raise ovimException(str(content
), -result
)
781 if net
["type"] != "ptp" and net
["type"] != "data":
786 self
.net_update_ofc_thread(net
['uuid'])
787 except ovimException
as e
:
788 raise ovimException("Error updating network'{}' {}".format(net
['uuid'], str(e
)),
789 HTTP_Internal_Server_Error
)
790 except Exception as e
:
791 raise ovimException("Error updating network '{}' {}".format(net
['uuid'], str(e
)),
792 HTTP_Internal_Server_Error
)
796 def delete_openflow_rules(self
, ofc_id
=None):
798 To make actions over the net. The action is to delete ALL openflow rules
799 :return: return operation result
803 if 'Default' in self
.config
['ofcs_thread']:
804 r
, c
= self
.config
['ofcs_thread']['Default'].insert_task("clear-all")
806 raise ovimException("Default Openflow controller not not running", HTTP_Not_Found
)
808 elif ofc_id
in self
.config
['ofcs_thread']:
809 r
, c
= self
.config
['ofcs_thread'][ofc_id
].insert_task("clear-all")
813 raise ovimException(str(c
), -r
)
815 raise ovimException("Openflow controller not found with ofc_id={}".format(ofc_id
), HTTP_Not_Found
)
818 def get_openflow_ports(self
, ofc_id
=None):
820 Obtain switch ports names of openflow controller
821 :return: Return flow ports in DB
824 if 'Default' in self
.config
['ofcs_thread']:
825 conn
= self
.config
['ofcs_thread']['Default'].OF_connector
827 raise ovimException("Default Openflow controller not not running", HTTP_Not_Found
)
829 if ofc_id
in self
.config
['ofcs_thread']:
830 conn
= self
.config
['ofcs_thread'][ofc_id
].OF_connector
832 raise ovimException("Openflow controller not found with ofc_id={}".format(ofc_id
), HTTP_Not_Found
)
835 def get_ports(self
, columns
=None, filter={}, limit
=None):
836 # result, content = my.db.get_ports(where_)
837 result
, content
= self
.db
.get_table(SELECT
=columns
, WHERE
=filter, FROM
='ports', LIMIT
=limit
)
839 self
.logger
.error("http_get_ports Error %d %s", result
, content
)
840 raise ovimException(str(content
), -result
)
842 convert_boolean(content
, ('admin_state_up',))
845 def new_port(self
, port_data
):
846 port_data
['type'] = 'external'
847 if port_data
.get('net_id'):
848 # check that new net has the correct type
849 result
, new_net
= self
.db
.check_target_net(port_data
['net_id'], None, 'external')
851 raise ovimException(str(new_net
), -result
)
852 # insert in data base
853 result
, uuid
= self
.db
.new_row('ports', port_data
, True, True)
855 if 'net_id' in port_data
:
857 self
.net_update_ofc_thread(port_data
['net_id'])
858 except ovimException
as e
:
859 raise ovimException("Cannot insert a task for updating network '{}' {}"
860 .format(port_data
['net_id'], str(e
)), HTTP_Internal_Server_Error
)
861 except Exception as e
:
862 raise ovimException("Cannot insert a task for updating network '{}' {}"
863 .format(port_data
['net_id'], str(e
)), HTTP_Internal_Server_Error
)
867 raise ovimException(str(uuid
), -result
)
869 def new_external_port(self
, port_data
):
871 Create new external port and check port mapping correspondence
872 :param port_data: port_data = {
873 'region': 'datacenter region',
874 'compute_node': 'compute node id',
875 'pci': 'pci port address',
878 'tenant_id': 'tenant id',
881 'ip_address': 'ip address - optional'}
885 port_data
['type'] = 'external'
887 if port_data
.get('net_id'):
888 # check that new net has the correct type
889 result
, new_net
= self
.db
.check_target_net(port_data
['net_id'], None, 'external')
891 raise ovimException(str(new_net
), -result
)
892 # insert in data base
895 if port_data
.get('region'):
896 db_filter
['region'] = port_data
['region']
897 if port_data
.get('pci'):
898 db_filter
['pci'] = port_data
['pci']
899 if port_data
.get('compute_node'):
900 db_filter
['compute_node'] = port_data
['compute_node']
902 columns
= ['ofc_id', 'switch_dpid', 'switch_port', 'switch_mac', 'pci']
903 port_mapping_data
= self
.get_of_port_mappings(columns
, db_filter
)
905 if not len(port_mapping_data
):
906 raise ovimException("No port mapping founded for '{}'".format(str(db_filter
)),
908 elif len(port_mapping_data
) > 1:
909 raise ovimException("Wrong port data was given, please check pci, region & compute id data",
912 port_data
['ofc_id'] = port_mapping_data
[0]['ofc_id']
913 port_data
['switch_dpid'] = port_mapping_data
[0]['switch_dpid']
914 port_data
['switch_port'] = port_mapping_data
[0]['switch_port']
915 port_data
['switch_mac'] = port_mapping_data
[0]['switch_mac']
917 # remove from compute_node, region and pci of_port_data to adapt to 'ports' structure
918 if 'region' in port_data
:
919 del port_data
['region']
920 if 'pci' in port_data
:
922 if 'compute_node' in port_data
:
923 del port_data
['compute_node']
925 result
, uuid
= self
.db
.new_row('ports', port_data
, True, True)
928 self
.net_update_ofc_thread(port_data
['net_id'], port_data
['ofc_id'])
929 except ovimException
as e
:
930 raise ovimException("Cannot insert a task for updating network '{}' {}".
931 format(port_data
['net_id'], str(e
)), HTTP_Internal_Server_Error
)
932 except Exception as e
:
933 raise ovimException("Cannot insert a task for updating network '{}' {}"
934 .format(port_data
['net_id'], e
), HTTP_Internal_Server_Error
)
937 raise ovimException(str(uuid
), -result
)
939 def net_update_ofc_thread(self
, net_id
, ofc_id
=None, switch_dpid
=None):
941 Insert a update net task by net id or ofc_id for each ofc thread
942 :param net_id: network id
943 :param ofc_id: openflow controller id
944 :param switch_dpid: switch dpid
948 raise ovimException("No net_id received", HTTP_Internal_Server_Error
)
951 c
= 'No valid ofc_id or switch_dpid received'
954 ports
= self
.get_ports(filter={"net_id": net_id
})
956 port_ofc_id
= port
.get('ofc_id', None)
958 ofc_id
= port
['ofc_id']
959 switch_dpid
= port
['switch_dpid']
961 #TODO if not ofc_id: look at database table ofcs
964 # If no ofc_id found it, default ofc_id is used.
965 if not ofc_id
and not switch_dpid
:
968 if ofc_id
and ofc_id
in self
.config
['ofcs_thread']:
969 r
, c
= self
.config
['ofcs_thread'][ofc_id
].insert_task("update-net", net_id
)
972 ofcs_dpid_list
= self
.config
['ofcs_thread_dpid']
973 for ofc_t
in ofcs_dpid_list
:
974 if switch_dpid
in ofc_t
:
975 r
, c
= ofc_t
[switch_dpid
].insert_task("update-net", net_id
)
978 message
= "Cannot insert a task for updating network '{}', {}".format(net_id
, c
)
979 self
.logger
.error(message
)
980 raise ovimException(message
, HTTP_Internal_Server_Error
)
982 def delete_port(self
, port_id
):
983 # Look for the previous port data
984 result
, ports
= self
.db
.get_table(WHERE
={'uuid': port_id
, "type": "external"}, FROM
='ports')
986 raise ovimException("Cannot get port info from database: {}".format(ports
), http_code
=-result
)
987 # delete from the data base
988 result
, content
= self
.db
.delete_row('ports', port_id
)
990 raise ovimException("External port '{}' not found".format(port_id
), http_code
=HTTP_Not_Found
)
992 raise ovimException("Cannot delete port from database: {}".format(content
), http_code
=-result
)
994 network
= ports
[0].get('net_id', None)
999 self
.net_update_ofc_thread(network
, ofc_id
=ports
[0]["ofc_id"], switch_dpid
=ports
[0]["switch_dpid"])
1000 except ovimException
as e
:
1001 raise ovimException("Cannot insert a task for delete network '{}' {}".format(network
, str(e
)),
1002 HTTP_Internal_Server_Error
)
1003 except Exception as e
:
1004 raise ovimException("Cannot insert a task for delete network '{}' {}".format(network
, str(e
)),
1005 HTTP_Internal_Server_Error
)
1009 def edit_port(self
, port_id
, port_data
, admin
=True):
1010 # Look for the previous port data
1011 result
, content
= self
.db
.get_table(FROM
="ports", WHERE
={'uuid': port_id
})
1013 raise ovimException("Cannot get port info from database: {}".format(content
), http_code
=-result
)
1015 raise ovimException("Port '{}' not found".format(port_id
), http_code
=HTTP_Not_Found
)
1020 if 'net_id' in port_data
:
1022 old_net
= port
.get('net_id', None)
1023 new_net
= port_data
['net_id']
1024 if old_net
!= new_net
:
1027 nets
.append(new_net
) # put first the new net, so that new openflow rules are created before removing the old ones
1029 nets
.append(old_net
)
1030 if port
['type'] == 'instance:bridge' or port
['type'] == 'instance:ovs':
1031 raise ovimException("bridge interfaces cannot be attached to a different net", http_code
=HTTP_Forbidden
)
1032 elif port
['type'] == 'external' and not admin
:
1033 raise ovimException("Needed admin privileges",http_code
=HTTP_Unauthorized
)
1035 # check that new net has the correct type
1036 result
, new_net_dict
= self
.db
.check_target_net(new_net
, None, port
['type'])
1038 raise ovimException("Error {}".format(new_net_dict
), http_code
=HTTP_Conflict
)
1039 # change VLAN for SR-IOV ports
1040 if result
>= 0 and port
["type"] == "instance:data" and port
["model"] == "VF": # TODO consider also VFnotShared
1042 port_data
["vlan"] = None
1044 port_data
["vlan"] = new_net_dict
["vlan"]
1045 # get host where this VM is allocated
1046 result
, content
= self
.db
.get_table(FROM
="instances", WHERE
={"uuid": port
["instance_id"]})
1048 host_id
= content
[0]["host_id"]
1050 # insert in data base
1052 result
, content
= self
.db
.update_rows('ports', port_data
, WHERE
={'uuid': port_id
}, log
=False)
1053 port
.update(port_data
)
1055 # Insert task to complete actions
1059 self
.net_update_ofc_thread(net_id
, port
["ofc_id"], switch_dpid
=port
["switch_dpid"])
1060 except ovimException
as e
:
1061 raise ovimException("Error updating network'{}' {}".format(net_id
, str(e
)),
1062 HTTP_Internal_Server_Error
)
1063 except Exception as e
:
1064 raise ovimException("Error updating network '{}' {}".format(net_id
, str(e
)),
1065 HTTP_Internal_Server_Error
)
1068 r
, v
= self
.config
['host_threads'][host_id
].insert_task("edit-iface", port_id
, old_net
, new_net
)
1070 self
.logger
.error("Error updating network '{}' {}".format(r
,v
))
1071 # TODO Do something if fails
1075 raise ovimException("Error {}".format(content
), http_code
=-result
)
1077 def new_of_controller(self
, ofc_data
):
1079 Create a new openflow controller into DB
1080 :param ofc_data: Dict openflow controller data
1081 :return: openflow controller dpid
1084 result
, ofc_uuid
= self
.db
.new_row('ofcs', ofc_data
, True, True)
1086 raise ovimException("New ofc Error %s" % ofc_uuid
, HTTP_Internal_Server_Error
)
1088 ofc_data
['uuid'] = ofc_uuid
1089 of_conn
= self
._load
_of
_module
(ofc_data
)
1090 self
._create
_ofc
_task
(ofc_uuid
, ofc_data
['dpid'], of_conn
)
1094 def edit_of_controller(self
, of_id
, ofc_data
):
1096 Edit an openflow controller entry from DB
1100 raise ovimException("No data received during uptade OF contorller", http_code
=HTTP_Internal_Server_Error
)
1102 old_of_controller
= self
.show_of_controller(of_id
)
1104 if old_of_controller
:
1105 result
, content
= self
.db
.update_rows('ofcs', ofc_data
, WHERE
={'uuid': of_id
}, log
=False)
1109 raise ovimException("Error uptating OF contorller with uuid {}".format(of_id
),
1112 raise ovimException("Error uptating OF contorller with uuid {}".format(of_id
),
1113 http_code
=HTTP_Internal_Server_Error
)
1115 def delete_of_controller(self
, of_id
):
1117 Delete an openflow controller from DB.
1118 :param of_id: openflow controller dpid
1122 ofc
= self
.show_of_controller(of_id
)
1124 result
, content
= self
.db
.delete_row("ofcs", of_id
)
1126 raise ovimException("Cannot delete ofc from database: {}".format(content
), http_code
=-result
)
1128 raise ovimException("ofc {} not found ".format(content
), http_code
=HTTP_Not_Found
)
1130 ofc_thread
= self
.config
['ofcs_thread'][of_id
]
1131 del self
.config
['ofcs_thread'][of_id
]
1132 for ofc_th
in self
.config
['ofcs_thread_dpid']:
1133 if ofc
['dpid'] in ofc_th
:
1134 self
.config
['ofcs_thread_dpid'].remove(ofc_th
)
1136 ofc_thread
.insert_task("exit")
1141 def show_of_controller(self
, uuid
):
1143 Show an openflow controller by dpid from DB.
1144 :param db_filter: List with where query parameters
1148 result
, content
= self
.db
.get_table(FROM
='ofcs', WHERE
={"uuid": uuid
}, LIMIT
=100)
1151 raise ovimException("Openflow controller with uuid '{}' not found".format(uuid
),
1152 http_code
=HTTP_Not_Found
)
1154 raise ovimException("Openflow controller with uuid '{}' error".format(uuid
),
1155 http_code
=HTTP_Internal_Server_Error
)
1158 def get_of_controllers(self
, columns
=None, db_filter
={}, limit
=None):
1160 Show an openflow controllers from DB.
1161 :param columns: List with SELECT query parameters
1162 :param db_filter: List with where query parameters
1163 :param limit: result Limit
1166 result
, content
= self
.db
.get_table(SELECT
=columns
, FROM
='ofcs', WHERE
=db_filter
, LIMIT
=limit
)
1169 raise ovimException(str(content
), -result
)
1173 def get_tenants(self
, columns
=None, db_filter
={}, limit
=None):
1175 Retrieve tenant list from DB
1176 :param columns: List with SELECT query parameters
1177 :param db_filter: List with where query parameters
1178 :param limit: result limit
1181 result
, content
= self
.db
.get_table(FROM
='tenants', SELECT
=columns
, WHERE
=db_filter
, LIMIT
=limit
)
1183 raise ovimException('get_tenatns Error {}'.format(str(content
)), -result
)
1185 convert_boolean(content
, ('enabled',))
1188 def show_tenant_id(self
, tenant_id
):
1190 Get tenant from DB by id
1191 :param tenant_id: tenant id
1194 result
, content
= self
.db
.get_table(FROM
='tenants', SELECT
=('uuid', 'name', 'description', 'enabled'),
1195 WHERE
={"uuid": tenant_id
})
1197 raise ovimException(str(content
), -result
)
1199 raise ovimException("tenant with uuid='{}' not found".format(tenant_id
), HTTP_Not_Found
)
1201 convert_boolean(content
, ('enabled',))
1204 def new_tentant(self
, tenant
):
1206 Create a tenant and store in DB
1207 :param tenant: Dictionary with tenant data
1208 :return: the uuid of created tenant. Raise exception upon error
1211 # insert in data base
1212 result
, tenant_uuid
= self
.db
.new_tenant(tenant
)
1217 raise ovimException(str(tenant_uuid
), -result
)
1219 def delete_tentant(self
, tenant_id
):
1221 Delete a tenant from the database.
1222 :param tenant_id: Tenant id
1223 :return: delete tenant id
1227 r
, tenants_flavors
= self
.db
.get_table(FROM
='tenants_flavors', SELECT
=('flavor_id', 'tenant_id'),
1228 WHERE
={'tenant_id': tenant_id
})
1230 tenants_flavors
= ()
1231 r
, tenants_images
= self
.db
.get_table(FROM
='tenants_images', SELECT
=('image_id', 'tenant_id'),
1232 WHERE
={'tenant_id': tenant_id
})
1236 result
, content
= self
.db
.delete_row('tenants', tenant_id
)
1238 raise ovimException("tenant '%s' not found" % tenant_id
, HTTP_Not_Found
)
1240 for flavor
in tenants_flavors
:
1241 self
.db
.delete_row_by_key("flavors", "uuid", flavor
['flavor_id'])
1242 for image
in tenants_images
:
1243 self
.db
.delete_row_by_key("images", "uuid", image
['image_id'])
1246 raise ovimException("Error deleting tenant '%s' " % tenant_id
, HTTP_Internal_Server_Error
)
1248 def edit_tenant(self
, tenant_id
, tenant_data
):
1250 Update a tenant data identified by tenant id
1251 :param tenant_id: tenant id
1252 :param tenant_data: Dictionary with tenant data
1256 # Look for the previous data
1257 result
, tenant_data_old
= self
.db
.get_table(FROM
='tenants', WHERE
={'uuid': tenant_id
})
1259 raise ovimException("Error updating tenant with uuid='{}': {}".format(tenant_id
, tenant_data_old
),
1260 HTTP_Internal_Server_Error
)
1262 raise ovimException("tenant with uuid='{}' not found".format(tenant_id
), HTTP_Not_Found
)
1264 # insert in data base
1265 result
, content
= self
.db
.update_rows('tenants', tenant_data
, WHERE
={'uuid': tenant_id
}, log
=True)
1269 raise ovimException(str(content
), -result
)
1271 def set_of_port_mapping(self
, of_maps
, ofc_id
=None, switch_dpid
=None, region
=None):
1273 Create new port mapping entry
1274 :param of_maps: List with port mapping information
1275 # maps =[{"ofc_id": <ofc_id>,"region": datacenter region,"compute_node": compute uuid,"pci": pci adress,
1276 "switch_dpid": swith dpid,"switch_port": port name,"switch_mac": mac}]
1277 :param ofc_id: ofc id
1278 :param switch_dpid: switch dpid
1279 :param region: datacenter region id
1285 map['ofc_id'] = ofc_id
1287 map['switch_dpid'] = switch_dpid
1289 map['region'] = region
1291 for of_map
in of_maps
:
1292 result
, uuid
= self
.db
.new_row('of_port_mappings', of_map
, True)
1294 of_map
["uuid"] = uuid
1296 raise ovimException(str(uuid
), -result
)
1299 def clear_of_port_mapping(self
, db_filter
={}):
1301 Clear port mapping filtering using db_filter dict
1302 :param db_filter: Parameter to filter during remove process
1305 result
, content
= self
.db
.delete_row_by_dict(FROM
='of_port_mappings', WHERE
=db_filter
)
1310 raise ovimException("Error deleting of_port_mappings with filter='{}'".format(str(db_filter
)),
1311 HTTP_Internal_Server_Error
)
1313 def get_of_port_mappings(self
, column
=None, db_filter
=None, db_limit
=None):
1315 Retrive port mapping from DB
1320 result
, content
= self
.db
.get_table(SELECT
=column
, WHERE
=db_filter
, FROM
='of_port_mappings', LIMIT
=db_limit
)
1323 self
.logger
.error("get_of_port_mappings Error %d %s", result
, content
)
1324 raise ovimException(str(content
), -result
)
1328 def get_dhcp_controller(self
):
1330 Create an host_thread object for manage openvim controller and not create a thread for itself
1331 :return: dhcp_host openvim controller object
1334 if 'openvim_controller' in self
.config
['host_threads']:
1335 return self
.config
['host_threads']['openvim_controller']
1338 controller_ip
= self
.config
['ovs_controller_ip']
1339 ovs_controller_user
= self
.config
['ovs_controller_user']
1341 host_test_mode
= True if self
.config
['mode'] == 'test' or self
.config
['mode'] == "OF only" else False
1342 host_develop_mode
= True if self
.config
['mode'] == 'development' else False
1344 dhcp_host
= ht
.host_thread(name
='openvim_controller', user
=ovs_controller_user
, host
=controller_ip
,
1346 db_lock
=self
.db_lock
, test
=host_test_mode
,
1347 image_path
=self
.config
['image_path'], version
=self
.config
['version'],
1348 host_id
='openvim_controller', develop_mode
=host_develop_mode
,
1349 develop_bridge_iface
=bridge_ifaces
, logger_name
=self
.logger_name
+ ".host.controller",
1350 debug
=self
.config
.get('log_level_host'))
1352 self
.config
['host_threads']['openvim_controller'] = dhcp_host
1353 if not host_test_mode
:
1354 dhcp_host
.ssh_connect()
1357 def launch_dhcp_server(self
, vlan
, first_ip
, last_ip
, cidr
, gateway
):
1359 Launch a dhcpserver base on dnsmasq attached to the net base on vlan id across the the openvim computes
1360 :param vlan: vlan identifier
1361 :param first_ip: First dhcp range ip
1362 :param last_ip: Last dhcp range ip
1363 :param cidr: net cidr
1364 :param gateway: net gateway
1367 ip_tools
= IPNetwork(cidr
)
1368 dhcp_netmask
= str(ip_tools
.netmask
)
1369 ip_range
= [first_ip
, last_ip
]
1371 dhcp_path
= self
.config
['ovs_controller_file_path']
1373 controller_host
= self
.get_dhcp_controller()
1374 controller_host
.create_linux_bridge(vlan
)
1375 controller_host
.create_dhcp_interfaces(vlan
, first_ip
, dhcp_netmask
)
1376 controller_host
.launch_dhcp_server(vlan
, ip_range
, dhcp_netmask
, dhcp_path
, gateway
)
1378 if __name__
== "__main__":
1380 parser
= argparse
.ArgumentParser()
1381 parser
.add_argument("-v","--version", help="show ovim library version", action
="store_true")
1382 parser
.add_argument("--database-version", help="show required database version", action
="store_true")
1383 args
= parser
.parse_args()
1385 print ('openvimd version {} {}'.format(ovim
.get_version(), ovim
.get_version_date()))
1386 print ('(c) Copyright Telefonica')
1387 elif args
.database_version
:
1388 print ('required database version: {}'.format(ovim
.get_database_version()))