def db_register_e3vswitch_interface(fields_create_dict):
session = db_sessions[DB_NAME]()
try:
session.begin()
iface = session.query(E3VswitchInterface).filter(
and_(
E3VswitchInterface.host_id == fields_create_dict['host_id'],
E3VswitchInterface.dev_address ==
fields_create_dict['dev_address'])).first()
if iface:
raise e3_exception(E3_EXCEPTION_BE_PRESENT)
else:
iface = E3VswitchInterface()
iface.id = str(uuid4())
for field in fields_create_dict:
setattr(iface, field, fields_create_dict[field])
session.add(iface)
session.commit()
e3loger.info('registering E3VswitchInterface:%s succeeds' %
(iface))
return iface.clone()
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def db_register_vswitch_ether_service_vlan(fields_create_dict):
session = db_sessions[DB_NAME]()
try:
session.begin()
vlan = session.query(E3EtherServiceVlan).filter(
and_(
E3EtherServiceVlan.lanzone_id ==
fields_create_dict['lanzone_id'], E3EtherServiceVlan.vlan_id ==
fields_create_dict['vlan_id'])).first()
if vlan:
raise e3_exception(E3_EXCEPTION_BE_PRESENT)
else:
vlan = E3EtherServiceVlan()
vlan.id = str(uuid4())
for field in fields_create_dict:
setattr(vlan, field, fields_create_dict[field])
session.add(vlan)
session.commit()
e3loger.info('registering E3EtherServiceVlan:%s succeeds' % (vlan))
return vlan.clone()
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def _prefetch_create_config(config, iResult):
assert (len(config['initial_lanzones']))
#prepare all essential object
#this will remove those duplicated ITEM. and may raise an exception if not found
iResult['initial_lanzones'] = list()
for l in config['initial_lanzones']:
iResult['initial_lanzones'].append(l)
e3loger.debug('initial lanzones:%s' % (iResult['initial_lanzones']))
iResult['ban_hosts'] = list()
for h in config['ban_hosts']:
iResult['ban_hosts'].append(h)
e3loger.debug('banned hosts:%s' % (iResult['ban_hosts']))
iResult['ban_lanzones'] = list()
for l in config['ban_lanzones']:
iResult['ban_lanzones'].append(l)
e3loger.debug('banned lanzones:%s' % (iResult['ban_lanzones']))
iResult['ban_interfaces'] = list()
for i in config['ban_interfaces']:
iResult['ban_interfaces'].append(i)
e3loger.debug('banned interfaces:%s' % (iResult['ban_interfaces']))
#make sure initial_lanzones do not overlap with ban_lanzones
bl = iResult['ban_lanzones']
for il in iResult['initial_lanzones']:
if il in bl:
raise e3_exception(E3_EXCEPTION_INVALID_ARGUMENT)
def get_channel(address, port, auto_create = True):
key = '%s:%s' % (address, port)
write_locked = False
try:
channel = _get_channel(address, port)
if not channel and auto_create:
channel_lock.write_lock()
write_locked = True
#create the channel if not present
secure_channel = get_config(None, 'grpc', 'secure_channel')
channel = None
if secure_channel == 'True':
public_crt_path = get_config(None, 'grpc', 'public_crt_path')
public_crt = None
with open(public_crt_path) as f:
public_crt = f.read().encode()
credentials = grpc.ssl_channel_credentials(root_certificates = public_crt)
channel = grpc.secure_channel(key, credentials)
else:
channel = grpc.insecure_channel(key)
gchannel = grpc_channel()
gchannel.channel = channel
channels[key] = gchannel
channel_lock.write_unlock()
write_locked = False
channel = _get_channel(address, port)
if not channel:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return channel
finally:
if write_locked:
channel_lock.write_unlock()
def db_register_vswitch_topology_edge(fields_create_dict):
session = db_sessions[DB_NAME]()
try:
session.begin()
edge = session.query(E3TopologyEdge).filter(
or_(
and_(
E3TopologyEdge.interface0 ==
fields_create_dict['interface0'], E3TopologyEdge.interface1
== fields_create_dict['interface1'],
E3TopologyEdge.service_id ==
fields_create_dict['service_id']),
and_(
E3TopologyEdge.interface0 ==
fields_create_dict['interface1'], E3TopologyEdge.interface1
== fields_create_dict['interface0'],
E3TopologyEdge.service_id ==
fields_create_dict['service_id']))).first()
if edge:
raise e3_exception(E3_EXCEPTION_BE_PRESENT)
edge = E3TopologyEdge()
edge.id = str(uuid4())
edge.interface0 = fields_create_dict['interface0']
edge.interface1 = fields_create_dict['interface1']
edge.service_id = fields_create_dict['service_id']
session.add(edge)
session.commit()
return edge.clone()
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def unregister_object(self,
root_key,
sub_key,
user_callback=None,
user_sync=False,
user_timeout=30):
if self._isReady() is False:
e3loger.warning('synchronization state not ready')
raise e3_exception(E3_EXCEPTION_NOT_SUPPORT,
'synchronization state not ready')
try:
dispatching_for_deletion[root_key](
**sub_key_to_args[root_key](sub_key))
#if no exception thrown,things go normal
#try to invoke another post callback with the same manner
e3loger.debug('invoking unregister_object_post for<%s,%s>' %
(root_key, sub_key))
self.unregister_object_post(root_key,
sub_key,
callback=user_callback,
sync=user_sync,
timeout=user_timeout)
except Exception as e:
e3loger.error('with given root_key:%s,sub_key:%s ' %
(str(root_key), str(sub_key)))
e3loger.error(str(traceback.format_exc()))
raise e
def update_object(self,
root_key,
sub_key,
fields_change_dict,
user_callback=None,
user_sync=False,
user_timeout=30):
if self._isReady() is False:
e3loger.warning('synchronization state not ready')
raise e3_exception(E3_EXCEPTION_NOT_SUPPORT, 'sync base not ready')
try:
args = sub_key_to_args[root_key](sub_key)
args['fields_change_dict'] = fields_change_dict
dispatching_for_update[root_key](**args)
e3loger.debug(
'invoking register_or_update_object_post for <%s:%s>' %
(root_key, sub_key))
self.register_or_update_object_post(root_key,
sub_key,
True,
callback=user_callback,
sync=user_sync,
timeout=user_timeout)
except Exception as e:
e3loger.error(
'with given root_key:%s sub_key:%s and fields_change_dict:%s' %
(str(root_key), str(sub_key), str(fields_change_dict)))
e3loger.error(str(traceback.format_exc()))
raise e
def register_object(self,
root_key,
fields_create_dict,
user_callback=None,
user_sync=False,
user_timeout=30):
if self._isReady() is False:
e3loger.warning('synchronization state not ready')
raise e3_exception(E3_EXCEPTION_NOT_SUPPORT, 'sync base not ready')
try:
obj = dispatching_for_registery[root_key](fields_create_dict)
assert (obj)
e3loger.debug(
'invoking register_or_update_object_post for <%s:%s>' %
(root_key, obj))
self.register_or_update_object_post(root_key,
obj.to_key(),
True,
callback=user_callback,
sync=user_sync,
timeout=user_timeout)
return obj
except Exception as e:
e3loger.error('with given root_key:%s and create_dict:%s' %
(str(root_key), str(fields_create_dict)))
e3loger.error(str(traceback.format_exc()))
raise e
def db_unregister_e3vswitch_interface(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
iface = session.query(E3VswitchInterface).filter(
E3VswitchInterface.id == uuid).first()
if not iface:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
if iface.reference_count != 0:
raise e3_exception(E3_EXCEPTION_IN_USE)
session.delete(iface)
session.commit()
e3loger.info('unregister E3VswitchInterface:%s' % (iface))
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def db_get_tenant(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
tenant = session.query(Tenant).filter(Tenant.id == uuid).first()
if not tenant:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return tenant.clone()
finally:
session.close()
def db_update_tenant(uuid, fields_change_dict):
session = db_sessions[DB_NAME]()
try:
session.begin()
tenant = session.query(Tenant).filter(Tenant.id == uuid).first()
if not tenant:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
for field in fields_change_dict:
if not hasattr(tenant, field):
raise e3_exception(E3_EXCEPTION_INVALID_ARGUMENT)
setattr(tenant, field, fields_change_dict[field])
session.commit()
e3loger.info('update Tenant(Tenant):%s with change:%s' %
(uuid, fields_change_dict))
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def db_get_vswitch_topology_edge(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
edge = session.query(E3TopologyEdge).filter(
E3TopologyEdge.id == uuid).first()
if not edge:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return edge.clone()
finally:
session.close()
def get_topology_neighbor(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
neighbor = session.query(topology_neighbor).filter(
topology_neighbor.id == uuid).first()
if not neighbor:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return neighbor.clone()
finally:
session.close()
def db_get_vswitch_ether_service(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
service = session.query(E3EtherService).filter(
E3EtherService.id == uuid).first()
if not service:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return service.clone()
finally:
session.close()
def unregister_topology_neighbor(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
neighbor = session.query(topology_neighbor).filter(
topology_neighbor.id == uuid).first()
if not neighbor:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
session.delete(neighbor)
session.commit()
finally:
session.close()
def db_get_token(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
token = session.query(Token).filter(Token.id == uuid).first()
if not token:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return token.clone()
except Exception as e:
raise e
finally:
session.close()
def is_locked(self, lock_path, caller_id, current_time):
try:
self._lock_native_guard.read_lock()
lock = self._locks.get(lock_path, None)
if lock:
lock_id, expiry_time = lock
if lock_id == caller_id and expiry_time > current_time:
return True
raise e3_exception(E3_EXCEPTION_NOT_READY)
except:
return False
finally:
self._lock_native_guard.read_unlock()
def db_get_ether_service(service_id):
session = db_sessions[DB_NAME]()
try:
ether_service_guard.read_lock()
session.begin()
service = session.query(agent_ether_service).filter(
agent_ether_service.id == service_id).first()
if not service:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return service.clone()
finally:
session.close()
ether_service_guard.read_unlock()
def db_update_e3vswitch_interface(uuid, fields_change_dict):
session = db_sessions[DB_NAME]()
try:
session.begin()
iface = session.query(E3VswitchInterface).filter(
E3VswitchInterface.id == uuid).first()
if not iface:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
for field in fields_change_dict:
if not hasattr(iface, field):
raise e3_exception(
E3_EXCEPTION_INVALID_ARGUMENT,
'%s is not a valid field of E3VswitchInterface' % (field))
setattr(iface, field, fields_change_dict[field])
session.commit()
e3loger.info('update E3VswitchLANZone:%s with change:%s' %
(uuid, fields_change_dict))
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def db_delete_ether_service(service_id):
session = db_sessions[DB_NAME]()
try:
ether_service_guard.write_lock()
session.begin()
service = session.query(agent_ether_service).filter(
agent_ether_service.id == service_id).first()
if not service:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
session.delete(service)
session.commit()
finally:
session.close()
ether_service_guard.write_unlock()
def get_topology_neighbor_by_interfaces(local_interface_id,
remote_interface_id):
session = db_sessions[DB_NAME]()
try:
session.begin()
neighbor = session.query(topology_neighbor).filter(
and_(topology_neighbor.local_interface_id == local_interface_id,
topology_neighbor.remote_interface_id ==
remote_interface_id)).first()
if not neighbor:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return neighbor.clone()
finally:
session.close()
def db_get_e3vswitch_interface(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
iface = session.query(E3VswitchInterface).filter(
E3VswitchInterface.id == uuid).first()
if not iface:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return iface.clone()
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def rpc_get_vswitch_host(self, request, context):
host = None
if request.per_uuid == True:
host = invt_get_vswitch_host(request.uuid)
else:
hosts = invt_list_vswitch_hosts()
for _host_id in hosts:
_host = hosts[_host_id]
if _host.name == request.host_name:
host = _host
break
if not host:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return to_vswitch_host_pb2(host)
def db_delete_topology_label(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
topology_label_guard.write_lock()
label = session.query(topology_label).filter(
topology_label.id == uuid).first()
if not label:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
session.delete(label)
session.commit()
finally:
topology_label_guard.write_unlock()
session.close()
def db_update_e3vswitch_host(uuid, fields_change_dict):
session = db_sessions[DB_NAME]()
try:
session.begin()
host = session.query(E3VswitchHost).filter(
E3VswitchHost.id == uuid).first()
if not host:
raise e3_exception(E3_EXCEPTION_NOT_FOUND,
'vswitch host %s not found' % (uuid))
for field in fields_change_dict:
if not hasattr(host, field):
raise e3_exception(E3_EXCEPTION_INVALID_ARGUMENT,
'%s is not a valid field of E3VswitchHost' %
(field))
setattr(host, field, fields_change_dict[field])
session.commit()
e3loger.info('update E3VswitchHost:%s with change:%s' %
(uuid, fields_change_dict))
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def db_update_token(uuid, fields_change_dict=None):
session = db_sessions[DB_NAME]()
try:
session.begin()
token = session.query(Token).filter(Token.id == uuid).first()
if not token:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
token.created_at = datetime.now()
session.commit()
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def db_unregister_token(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
token = session.query(Token).filter(Token.id == uuid).first()
if not token:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
session.delete(token)
session.commit()
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def db_unregister_vswitch_topology_edge(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
edge = session.query(E3TopologyEdge).filter(
E3TopologyEdge.id == uuid).first()
if not edge:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
session.delete(edge)
session.commit()
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def db_unregiser_vswitch_service(uuid):
session = db_sessions[DB_NAME]()
try:
session.begin()
service = session.query(E3EtherService).filter(
E3EtherService.id == uuid).first()
if not service:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
session.delete(service)
session.commit()
except Exception as e:
session.rollback()
raise e
finally:
session.close()
def db_get_e3vswitch_lanzone(uuid):
session = db_sessions[DB_NAME]()
lanzone = None
try:
session.begin()
lanzone = session.query(E3VswitchLANZone).filter(
E3VswitchLANZone.id == uuid).first()
if not lanzone:
raise e3_exception(E3_EXCEPTION_NOT_FOUND)
return lanzone.clone()
except Exception as e:
session.rollback()
raise e
finally:
session.close()
