1 # -*- coding: utf-8 -*-
3 # Copyright 2018 Whitestack, LLC
4 # *************************************************************
6 # This file is part of OSM RO module
7 # All Rights Reserved to Whitestack, LLC
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
20 # For those usages not covered by the Apache License, Version 2.0 please
21 # contact: bdiaz@whitestack.com or glavado@whitestack.com
28 from osm_ro_plugin
.sdnconn
import SdnConnectorBase
, SdnConnectorError
30 from requests
.auth
import HTTPBasicAuth
33 class OnosVpls(SdnConnectorBase
):
35 https://wiki.onosproject.org/display/ONOS/VPLS+User+Guide
38 _WIM_LOGGER
= "ro.sdn.onosvpls"
40 def __init__(self
, wim
, wim_account
, config
=None, logger
=None):
41 self
.logger
= logger
or logging
.getLogger(self
._WIM
_LOGGER
)
42 super().__init
__(wim
, wim_account
, config
, logger
)
43 self
.user
= wim_account
.get("user")
44 self
.password
= wim_account
.get("password")
45 url
= wim
.get("wim_url")
48 raise SdnConnectorError("'url' must be provided")
50 if not url
.startswith("http"):
53 if not url
.endswith("/"):
56 self
.url
= url
+ "onos/v1/network/configuration"
57 self
.logger
.info("ONOS VPLS Connector Initialized.")
59 def check_credentials(self
):
61 onos_config_req
= None
64 onos_config_req
= requests
.get(
65 self
.url
, auth
=HTTPBasicAuth(self
.user
, self
.password
)
67 onos_config_req
.raise_for_status()
68 except Exception as e
:
70 status_code
= onos_config_req
.status_code
72 self
.logger
.exception("Error checking credentials: {}".format(e
))
74 raise SdnConnectorError(
75 "Error checking credentials: {}".format(e
), http_code
=status_code
78 def get_connectivity_service_status(self
, service_uuid
, conn_info
=None):
80 onos_config
= self
._get
_onos
_netconfig
()
81 vpls_config
= onos_config
.get("apps", {}).get("org.onosproject.vpls")
83 for vpls
in vpls_config
.get("vpls", {}).get("vplsList"):
84 if vpls
.get("name") == service_uuid
:
85 return {"sdn_status": "ACTIVE", "sdn_info": vpls
}
87 return {"sdn_status": "ERROR", "sdn_info": "not found"}
88 except Exception as e
:
89 self
.logger
.error("Exception getting connectivity service info: %s", e
)
91 return {"sdn_status": "ERROR", "error_msg": str(e
)}
93 def _get_onos_netconfig(self
):
95 onos_config_req
= requests
.get(
96 self
.url
, auth
=HTTPBasicAuth(self
.user
, self
.password
)
98 status_code
= onos_config_req
.status_code
100 if status_code
== requests
.codes
.ok
:
101 return onos_config_req
.json()
104 "Error obtaining network config, status code: {}".format(
109 raise SdnConnectorError(
110 "Error obtaining network config status code: {}".format(
113 http_code
=status_code
,
115 except requests
.exceptions
.ConnectionError
as e
:
116 self
.logger
.info("Exception connecting to onos: %s", e
)
118 raise SdnConnectorError("Error connecting to onos: {}".format(e
))
119 except Exception as e
:
120 self
.logger
.error("Exception getting onos network config: %s", e
)
122 raise SdnConnectorError(
123 "Exception getting onos network config: {}".format(e
)
126 def _post_onos_netconfig(self
, onos_config
):
128 onos_config_resp
= requests
.post(
129 self
.url
, json
=onos_config
, auth
=HTTPBasicAuth(self
.user
, self
.password
)
131 status_code
= onos_config_resp
.status_code
133 if status_code
!= requests
.codes
.ok
:
135 "Error updating network config, status code: {}".format(status_code
)
138 raise SdnConnectorError(
139 "Error obtaining network config status code: {}".format(
142 http_code
=status_code
,
144 except requests
.exceptions
.ConnectionError
as e
:
145 self
.logger
.info("Exception connecting to onos: %s", e
)
147 raise SdnConnectorError("Error connecting to onos: {}".format(e
))
148 except Exception as e
:
149 self
.logger
.info("Exception posting onos network config: %s", e
)
151 raise SdnConnectorError(
152 "Exception posting onos network config: {}".format(e
)
155 def create_connectivity_service(self
, service_type
, connection_points
, **kwargs
):
157 "create_connectivity_service, service_type: {}, connection_points: {}".format(
158 service_type
, connection_points
162 if service_type
.lower() == "etree":
163 raise SdnConnectorError(
164 "Only ELINE/ELAN network type is supported by ONOS VPLS."
167 # FIXME ¿must check number of connection_points?
168 service_uuid
= str(uuid
.uuid4())
170 # Obtain current configuration
171 onos_config_orig
= self
._get
_onos
_netconfig
()
172 # self.logger.debug("onos config: %s", onos_config_orig)
173 onos_config
= copy
.deepcopy(onos_config_orig
)
176 # Create missing interfaces, append to created_items if returned, append_port_to_onos_config
177 # returns null if it was already created
180 for port
in connection_points
:
181 created_ifz
= self
._append
_port
_to
_onos
_config
(port
, onos_config
)
183 created_items
.append(created_ifz
[1])
185 self
._post
_onos
_netconfig
(onos_config
)
187 # Add vpls service to config
188 encapsulation
= self
._get
_encapsulation
(connection_points
)
189 interfaces
= [port
.get("service_endpoint_id") for port
in connection_points
]
191 if "org.onosproject.vpls" in onos_config
["apps"]:
192 if "vpls" not in onos_config
["apps"]["org.onosproject.vpls"]:
193 onos_config
["apps"]["org.onosproject.vpls"]["vpls"] = {
197 for vpls
in onos_config
["apps"]["org.onosproject.vpls"]["vpls"][
200 if vpls
["name"] == service_uuid
:
201 raise SdnConnectorError(
202 "Network {} already exists.".format(service_uuid
)
205 onos_config
["apps"]["org.onosproject.vpls"]["vpls"]["vplsList"].append(
207 "name": service_uuid
,
208 "interfaces": interfaces
,
209 "encapsulation": encapsulation
,
212 self
._pop
_last
_update
_time
(onos_config
)
214 onos_config
["apps"] = {
215 "org.onosproject.vpls": {
219 "name": service_uuid
,
220 "interfaces": interfaces
,
221 "encapsulation": encapsulation
,
227 # self.logger.debug("original config: %s", onos_config_orig)
228 # self.logger.debug("original config: %s", onos_config)
229 self
._post
_onos
_netconfig
(onos_config
)
232 "created connectivity_service, service_uuid: {}, created_items: {}".format(
233 service_uuid
, created_items
237 return service_uuid
, {"interfaces": created_items
}
238 except Exception as e
:
239 self
.logger
.error("Exception add connection_service: %s", e
)
241 # try to rollback push original config
243 self
._post
_onos
_netconfig
(onos_config_orig
)
244 except Exception as rollback_e
:
246 "Exception rolling back to original config: %s", rollback_e
250 if isinstance(e
, SdnConnectorError
):
253 raise SdnConnectorError(
254 "Exception create_connectivity_service: {}".format(e
)
257 def _get_encapsulation(self
, connection_points
):
259 Obtains encapsulation for the vpls service from the connection_points
260 FIXME: Encapsulation is defined for the connection points but for the VPLS service the encapsulation is
261 defined at the service level so only one can be assigned
263 # check if encapsulation is vlan, check just one connection point
264 encapsulation
= "NONE"
265 for connection_point
in connection_points
:
266 if connection_point
.get("service_endpoint_encapsulation_type") == "dot1q":
267 encapsulation
= "VLAN"
272 def edit_connectivity_service(
273 self
, service_uuid
, conn_info
=None, connection_points
=None, **kwargs
276 "edit connectivity service, service_uuid: {}, conn_info: {}, "
277 "connection points: {} ".format(service_uuid
, conn_info
, connection_points
)
280 conn_info
= conn_info
or {}
281 created_ifs
= conn_info
.get("interfaces", [])
283 # Obtain current configuration
284 onos_config_orig
= self
._get
_onos
_netconfig
()
285 onos_config
= copy
.deepcopy(onos_config_orig
)
287 # get current service data and check if it does not exists
289 onos_config
.get("apps", {})
290 .get("org.onosproject.vpls", {})
294 if vpls
["name"] == service_uuid
:
295 self
.logger
.debug("service exists")
296 curr_interfaces
= vpls
.get("interfaces", [])
297 curr_encapsulation
= vpls
.get("encapsulation")
300 raise SdnConnectorError(
301 "service uuid: {} does not exist".format(service_uuid
)
304 self
.logger
.debug("current interfaces: {}".format(curr_interfaces
))
305 self
.logger
.debug("current encapsulation: {}".format(curr_encapsulation
))
307 # new interfaces names
308 new_interfaces
= [port
["service_endpoint_id"] for port
in connection_points
]
310 # obtain interfaces to delete, list will contain port
311 ifs_delete
= list(set(curr_interfaces
) - set(new_interfaces
))
312 ifs_add
= list(set(new_interfaces
) - set(curr_interfaces
))
313 self
.logger
.debug("interfaces to delete: {}".format(ifs_delete
))
314 self
.logger
.debug("interfaces to add: {}".format(ifs_add
))
316 # check if some data of the interfaces that already existed has changed
317 # in that case delete it and add it again
318 ifs_remain
= list(set(new_interfaces
) & set(curr_interfaces
))
319 for port
in connection_points
:
320 if port
["service_endpoint_id"] in ifs_remain
:
321 # check if there are some changes
322 curr_port_name
, curr_vlan
= self
._get
_current
_port
_data
(
323 onos_config
, port
["service_endpoint_id"]
325 new_port_name
= "of:{}/{}".format(
326 port
["service_endpoint_encapsulation_info"]["switch_dpid"],
327 port
["service_endpoint_encapsulation_info"]["switch_port"],
329 new_vlan
= port
["service_endpoint_encapsulation_info"]["vlan"]
331 if curr_port_name
!= new_port_name
or curr_vlan
!= new_vlan
:
333 "TODO: must update data interface: {}".format(
334 port
["service_endpoint_id"]
337 ifs_delete
.append(port
["service_endpoint_id"])
338 ifs_add
.append(port
["service_endpoint_id"])
340 new_encapsulation
= self
._get
_encapsulation
(connection_points
)
343 # Delete interfaces, only will delete interfaces that are in provided conn_info
344 # because these are the ones that have been created for this service
346 for port
in onos_config
["ports"].values():
347 for port_interface
in port
["interfaces"]:
348 interface_name
= port_interface
["name"]
350 "interface name: {}".format(port_interface
["name"])
354 interface_name
in ifs_delete
355 and interface_name
in created_ifs
358 "delete interface name: {}".format(interface_name
)
360 port
["interfaces"].remove(port_interface
)
361 created_ifs
.remove(interface_name
)
364 for port
in connection_points
:
365 if port
["service_endpoint_id"] in ifs_add
:
366 created_ifz
= self
._append
_port
_to
_onos
_config
(port
, onos_config
)
368 created_ifs
.append(created_ifz
[1])
370 self
._pop
_last
_update
_time
(onos_config
)
371 self
._post
_onos
_netconfig
(onos_config
)
374 "onos config after updating interfaces: {}".format(onos_config
)
377 "created_ifs after updating interfaces: {}".format(created_ifs
)
380 # Update interfaces list in vpls service
382 onos_config
.get("apps", {})
383 .get("org.onosproject.vpls", {})
387 if vpls
["name"] == service_uuid
:
388 vpls
["interfaces"] = new_interfaces
389 vpls
["encapsulation"] = new_encapsulation
391 self
._pop
_last
_update
_time
(onos_config
)
392 self
._post
_onos
_netconfig
(onos_config
)
394 return {"interfaces": created_ifs
}
395 except Exception as e
:
396 self
.logger
.error("Exception add connection_service: %s", e
)
397 # try to rollback push original config
399 self
._post
_onos
_netconfig
(onos_config_orig
)
400 except Exception as e2
:
401 self
.logger
.error("Exception rolling back to original config: %s", e2
)
403 if isinstance(e
, SdnConnectorError
):
406 raise SdnConnectorError(
407 "Exception create_connectivity_service: {}".format(e
)
410 def delete_connectivity_service(self
, service_uuid
, conn_info
=None):
411 self
.logger
.debug("delete_connectivity_service uuid: {}".format(service_uuid
))
413 conn_info
= conn_info
or {}
414 created_ifs
= conn_info
.get("interfaces", [])
415 # Obtain current config
416 onos_config
= self
._get
_onos
_netconfig
()
419 # Removes ports used by network from onos config
421 onos_config
.get("apps", {})
422 .get("org.onosproject.vpls", {})
426 if vpls
["name"] == service_uuid
:
427 # iterate interfaces to check if must delete them
428 for interface
in vpls
["interfaces"]:
429 for port
in onos_config
["ports"].values():
430 for port_interface
in port
["interfaces"]:
431 if port_interface
["name"] == interface
:
432 # Delete only created ifzs
433 if port_interface
["name"] in created_ifs
:
435 "Delete ifz: {}".format(
436 port_interface
["name"]
439 port
["interfaces"].remove(port_interface
)
440 onos_config
["apps"]["org.onosproject.vpls"]["vpls"][
445 raise SdnConnectorError(
446 "service uuid: {} does not exist".format(service_uuid
)
449 self
._pop
_last
_update
_time
(onos_config
)
450 self
._post
_onos
_netconfig
(onos_config
)
452 "deleted connectivity service uuid: {}".format(service_uuid
)
454 except SdnConnectorError
:
456 except Exception as e
:
458 "Exception delete connection_service: %s", e
, exc_info
=True
461 raise SdnConnectorError(
462 "Exception delete connectivity service: {}".format(str(e
))
465 def _pop_last_update_time(self
, onos_config
):
467 Needed before post when there are already configured vpls services to apply changes
469 onos_config
["apps"]["org.onosproject.vpls"]["vpls"].pop("lastUpdateTime", None)
471 def _get_current_port_data(self
, onos_config
, interface_name
):
472 for port_name
, port
in onos_config
["ports"].items():
473 for port_interface
in port
["interfaces"]:
474 if port_interface
["name"] == interface_name
:
475 return port_name
, port_interface
["vlan"]
477 def _append_port_to_onos_config(self
, port
, onos_config
):
479 port_name
= "of:{}/{}".format(
480 port
["service_endpoint_encapsulation_info"]["switch_dpid"],
481 port
["service_endpoint_encapsulation_info"]["switch_port"],
483 interface_config
= {"name": port
["service_endpoint_id"]}
486 "vlan" in port
["service_endpoint_encapsulation_info"]
487 and port
["service_endpoint_encapsulation_info"]["vlan"]
489 interface_config
["vlan"] = port
["service_endpoint_encapsulation_info"][
494 port_name
in onos_config
["ports"]
495 and "interfaces" in onos_config
["ports"][port_name
]
497 for interface
in onos_config
["ports"][port_name
]["interfaces"]:
498 if interface
["name"] == port
["service_endpoint_id"]:
499 # self.logger.debug("interface with same name and port exits")
500 # interface already exists TODO ¿check vlan? ¿delete and recreate?
501 # by the moment use and do not touch
502 # onos_config['ports'][port_name]['interfaces'].remove(interface)
505 # self.logger.debug("port with same name exits but not interface")
506 onos_config
["ports"][port_name
]["interfaces"].append(interface_config
)
507 created_item
= (port_name
, port
["service_endpoint_id"])
509 # self.logger.debug("create port and interface")
510 onos_config
["ports"][port_name
] = {"interfaces": [interface_config
]}
511 created_item
= (port_name
, port
["service_endpoint_id"])
516 if __name__
== "__main__":
517 logger
= logging
.getLogger("ro.sdn.onos_vpls")
518 logging
.basicConfig()
519 logger
.setLevel(getattr(logging
, "DEBUG"))
520 # wim_url = "http://10.95.172.251:8181"
521 wim_url
= "http://192.168.56.106:8181"
524 wim
= {"wim_url": wim_url
}
525 wim_account
= {"user": user
, "password": password
}
526 onos_vpls
= OnosVpls(wim
=wim
, wim_account
=wim_account
, logger
=logger
)
527 # conn_service = onos_vpls.get_connectivity_service_status("4e1f4c8a-a874-425d-a9b5-955cb77178f8")
528 # print(conn_service)
529 service_type
= "ELAN"
531 "service_endpoint_id": "switch1:ifz1",
532 "service_endpoint_encapsulation_type": "dot1q",
533 "service_endpoint_encapsulation_info": {
534 "switch_dpid": "0000000000000011",
540 "service_endpoint_id": "switch3:ifz1",
541 "service_endpoint_encapsulation_type": "dot1q",
542 "service_endpoint_encapsulation_info": {
543 "switch_dpid": "0000000000000031",
548 connection_points
= [conn_point_0
, conn_point_1
]
549 # service_uuid, conn_info = onos_vpls.create_connectivity_service(service_type, connection_points)
550 # print(service_uuid)
554 conn_info
= {"interfaces": ["switch1:ifz1", "switch3:ifz1"]}
555 # onos_vpls.delete_connectivity_service("70248a41-11cb-44f3-9039-c41387394a30", conn_info)
558 "service_endpoint_id": "switch1:ifz1",
559 "service_endpoint_encapsulation_type": "dot1q",
560 "service_endpoint_encapsulation_info": {
561 "switch_dpid": "0000000000000011",
567 "service_endpoint_id": "switch1:ifz3",
568 "service_endpoint_encapsulation_type": "dot1q",
569 "service_endpoint_encapsulation_info": {
570 "switch_dpid": "0000000000000011",
576 "service_endpoint_id": "switch2:ifz2",
577 "service_endpoint_encapsulation_type": "dot1q",
578 "service_endpoint_encapsulation_info": {
579 "switch_dpid": "0000000000000022",
584 connection_points_2
= [conn_point_0
, conn_point_3
]
585 # conn_info = onos_vpls.edit_connectivity_service("c65d88be-73aa-4933-927d-57ec6bee6b41",
586 # conn_info, connection_points_2)
589 service_status
= onos_vpls
.get_connectivity_service_status(
590 "c65d88be-73aa-4933-927d-57ec6bee6b41", conn_info
592 print("service status")
593 print(service_status
)