def getOpenflowController(self, controller_id):
session = get_session()
try:
return session.query(OpenflowControllerModel).filter_by(id = controller_id).one()
except Exception as ex:
logging.error(ex)
raise ControllerNotFound("Node not found: "+str(controller_id))
def getOpenflowControllerID(self, node_id):
session = get_session()
try:
return session.query(NodeModel.openflow_controller).filter_by(id = node_id).one().openflow_controller
except Exception as ex:
logging.error(ex)
raise NodeNotFound("Node not found: "+str(node_id))
def getDomainIDfromNode(self, node):
session = get_session()
with session.begin():
domain = session.query(DomainsInformationModel).filter_by(node = node).first()
if domain is None:
return None
return domain.domain_id
def getNodeFromDomainID(self, domain_id):
session = get_session()
try:
return session.query(NodeModel).filter_by(domain_id = domain_id).one()
except Exception as ex:
logging.error(ex)
raise NodeNotFound("Node not found for domain id: "+str(domain_id))
def getNode(self, node_id):
session = get_session()
try:
return session.query(NodeModel).filter_by(id = node_id).one()
except Exception as ex:
logging.error(ex)
raise NodeNotFound("Node not found: "+str(node_id))
def get_domain_info(self, domain_name=None):
session = get_session()
domains_info_list = {}
if domain_name is not None:
pass
else:
domains_refs = session.query(DomainsInformationModel).all()
for domain_ref in domains_refs:
if domain_ref.domain_id not in domains_info_list:
domain_type = session.query(DomainModel).filter_by(id = domain_ref.domain_id).one().type
domain_info = DomainInfo(domain_id=domain_ref.domain_id, _type=domain_type)
domains_info_list[domain_ref.domain_id]=domain_info
else:
domain_info = domains_info_list[domain_ref.domain_id]
intf = Interface(node=domain_ref.node, name=domain_ref.interface, _type=domain_ref.interface_type, gre=domain_ref.gre, vlan=domain_ref.vlan)
if intf.gre is True:
gre_refs = session.query(DomainsGreModel).filter_by(domain_info_id=domain_ref.id).all()
for gre_ref in gre_refs:
gre_tunnel = GreTunnel(name=gre_ref.name, local_ip=gre_ref.local_ip, remote_ip=gre_ref.remote_ip, gre_key=gre_ref.gre_key)
intf.addGreTunnel(gre_tunnel)
if intf.vlan is True:
vlan_refs = session.query(DomainsVlanModel).filter_by(domain_info_id=domain_ref.id).all()
for vlan_ref in vlan_refs:
for vlan_id in range(vlan_ref.vlan_start, vlan_ref.vlan_end+1):
intf.addVlan(vlan_id)
neighbor_refs = session.query(DomainsNeighborModel).filter_by(domain_info_id=domain_ref.id).all()
for neighbor_ref in neighbor_refs:
neighbor = Neighbor(domain_name=neighbor_ref.neighbor_domain_name, node=neighbor_ref.neighbor_node, interface=neighbor_ref.neighbor_interface, domain_type=neighbor_ref.neighbor_domain_type)
intf.addNeighbor(neighbor)
domain_info.addInterface(intf)
return domains_info_list
def get_profile_id_from_active_user_session(self, user_id):
session = get_session()
session_ref = session.query(SessionModel.service_graph_id).filter_by(user_id = user_id).filter_by(ended = None).filter_by(error = None).first()
if session_ref is None:
raise sessionNotFound("Session Not Found")
return session_ref.service_graph_id
def set_ended(self, session_id):
'''
Set the ended status for the session identified with session_id
'''
session = get_session()
with session.begin():
session.query(SessionModel).filter_by(id=session_id).update({"ended":datetime.datetime.now()}, synchronize_session = False)
def updateSession(self, session_id, ingress_node, egress_node, status):
'''
store the session in db
'''
session = get_session()
with session.begin():
session.query(SessionModel).filter_by(id = session_id).filter_by(ended = None).filter_by(error = None).update({"last_update":datetime.datetime.now(), "ingress_node":ingress_node, "egress_node": egress_node, 'status':status})
def getTenantName(self, tenant_id):
session = get_session()
try:
return session.query(TenantModel).filter_by(id = tenant_id).one().name
except Exception as ex:
logging.error(ex)
raise TenantNotFound("User not found: "+str(tenant_id))
def getDomainFromName(self, name):
session = get_session()
try:
return session.query(DomainModel).filter_by(name = name).one()
except Exception as ex:
logging.exception(ex)
raise DomainNotFound("Domain not found for name: "+str(name)) from None
def getUser(self, username):
session = get_session()
try:
return session.query(UserModel).filter_by(name = username).one()
except Exception as ex:
#logging.error(ex)
raise UserNotFound("User not found: "+str(username)) from None
def getUserFromID(self, user_id):
session = get_session()
try:
return session.query(UserModel).filter_by(id = user_id).one()
except Exception as ex:
logging.error(ex)
raise UserNotFound("User not found id: "+str(user_id))
def getConfiguationModel(self, image_internal_id):
session = get_session()
try:
return session.query(VNFImage).filter_by(internal_id = image_internal_id).one().configuration_model
except Exception as ex:
logging.error(ex)
raise Exception("No configuration model found for image id: "+str(image_internal_id))
def getTemplate(self, image_internal_id):
session = get_session()
try:
return session.query(VNFImage).filter_by(internal_id = image_internal_id).one().template
except Exception as ex:
logging.error(ex)
raise Exception("No template found for image id: "+str(image_internal_id))
def getInstantiationNode(self):
session = get_session()
try:
return session.query(NodeModel).filter(NodeModel.type != 'HeatCA' ).one()
except Exception as ex:
logging.error(ex)
raise NodeNotFound("Node not found.")
def get_active_user_session_from_id(self, session_id):
session = get_session()
with session.begin():
user_session = session.query(SessionModel).filter_by(id=session_id).filter_by(ended = None).filter_by(error = None).first()
if not user_session:
raise sessionNotFound("Session Not Found")
return user_session
def getDomainIP(self, domain_id):
session = get_session()
try:
return session.query(DomainModel).filter_by(id = domain_id).one().ip
except Exception as ex:
logging.exception(ex)
raise DomainNotFound("Domain not found: "+str(domain_id)) from None
def getComponentAdapter(self, node_id):
session = get_session()
logging.debug("node_id: "+str(node_id))
try:
return session.query(NodeModel.type).filter_by(id = node_id).one().type
except Exception as ex:
logging.error(ex)
raise NodeNotFound("Node not found")
def set_error(self, session_id):
'''
Set the error status for the active session associated to the user id passed
'''
session = get_session()
with session.begin():
logging.debug("Put session for session "+str(session_id)+" in error")
session.query(SessionModel).filter_by(id=session_id).filter_by(ended = None).filter_by(error = None).update({"error":datetime.datetime.now()}, synchronize_session = False)
def get_active_user_session(self, user_id):
'''
returns if exists an active session of the user
'''
session = get_session()
session_ref = session.query(SessionModel).filter_by(user_id = user_id).filter_by(ended = None).filter_by(error = None).first()
if session_ref is None:
raise sessionNotFound("Session Not Found")
return session_ref
def get_active_user_session_by_nf_fg_id(self, service_graph_id, error_aware=True):
session = get_session()
if error_aware:
session_ref = session.query(SessionModel).filter_by(service_graph_id = service_graph_id).filter_by(ended = None).filter_by(error = None).first()
else:
session_ref = session.query(SessionModel).filter_by(service_graph_id = service_graph_id).filter_by(ended = None).order_by(desc(SessionModel.started_at)).first()
if session_ref is None:
raise sessionNotFound("Session Not Found, for servce graph id: "+str(service_graph_id))
return session_ref
def get_active_user_devices(self, user_id):
session = get_session()
user_sessions = session.query(SessionModel.id).filter_by(user_id = user_id).filter_by(ended = None).filter_by(error = None).all()
mac_addresses = []
for user_session in user_sessions:
devices = session.query(UserDeviceModel).filter_by(session_id = user_session.id).all()
for device in devices:
mac_addresses.append(device.mac_address)
return mac_addresses
def updateUserToken(self, domain_id, user_id, token):
session = get_session()
with session.begin():
domain_token = session.query(DomainTokenModel).filter_by(user_id=user_id).filter_by(domain_id=domain_id).one_or_none()
if domain_token is not None:
session.query(DomainTokenModel).filter_by(user_id=user_id).filter_by(domain_id=domain_id).update({"token":token})
else:
domain_token = DomainTokenModel(user_id=user_id, domain_id=domain_id, token=token)
session.add(domain_token)
def checkIngressNode(self, node, profile):
"""
Return False if the only ingress point in the node
is that that we are deleting
"""
session = get_session()
ings = session.query(SessionModel).filter_by(ingress_node = node).filter(not_(Session.profile.contains(profile))).all()
if ings is not None and len(ings) == 0:
return False
return True
def getUserLocation(self, user_id):
'''
Ruturns the id of the node, where the User is connected
'''
session = get_session()
try:
return session.query(UserLocationModel.node_id).filter_by(user_id = user_id).one().node_id
except Exception as ex:
logging.error(ex)
raise UserLocationNotFound("It is not defined a default location for the user: "+str(user_id))
def inizializeSession(self, session_id, user_id, service_graph_id, service_graph_name):
'''
inizialize the session in db
'''
session = get_session()
with session.begin():
session_ref = SessionModel(id=session_id, user_id = user_id, service_graph_id = service_graph_id,
started_at = datetime.datetime.now(), service_graph_name=service_graph_name,
last_update = datetime.datetime.now(), status='inizialization')
session.add(session_ref)
pass
def checkDeviceSession(self, user_id, mac_address):
'''
return true if there is already an active session of the user with this mac
'''
session = get_session()
user_sessions =session.query(SessionModel).filter_by(user_id = user_id).filter_by(ended = None).filter_by(error = None).all()
for user_session in user_sessions:
devices = session.query(UserDeviceModel).filter_by(session_id = user_session.id).all()
for device in devices:
if device.mac_address == mac_address:
return True
return False
def addDomain(self, domain_name, domain_type, domain_ip, domain_port, update=False):
session = get_session()
with session.begin():
max_id = -1
domain_refs = session.query(DomainModel).all()
for domain_ref in domain_refs:
if domain_ref.id > max_id:
max_id = domain_ref.id
if domain_ref.name == domain_name and domain_ref.type == domain_type and domain_ref.ip == domain_ip and domain_ref.port == int(domain_port):
return domain_ref.id
domain = DomainModel(id=max_id+1, name=domain_name, type=domain_type, ip=domain_ip, port=domain_port)
session.add(domain)
return domain.id
def checkSession(self, user_id, token, graph_id = None):
'''
return true if there is already an active session of the user
'''
session = get_session()
if graph_id is None:
user_session = session.query(SessionModel).filter_by(user_id = user_id).filter_by(ended = None).filter_by(error = None).first()
else:
# TODO:
raise NotImplemented()
if user_session is None:
return False
else:
return True
