def _from_idl(nh_idl, ne):
if nh_idl == None:
return
addr = None
if nh_idl.nextHop and nh_idl.nextHop.address != None:
if isinstance(nh_idl, L3UcastRouteNextHopIDL):
addr = NetworkInterface._convert_to_inetaddress(
nh_idl.nextHop.address)
elif isinstance(nh_idl, L3UcastRouteNextHopOutIDL):
addr = nh_idl.nextHop.address.addr
scp = L3UnicastScope._from_idl(nh_idl.scope)
ni = None
try:
ni = NetworkInterface(ne, nh_idl.nextHop.name,
nh_idl.nextHop.interfaceType,
nh_idl.nextHop.xosHandle)
except OnepIllegalArgumentException as e:
L3UnicastNextHop.log.debug('failed to convert NetworkInterface ' +
e)
L3UnicastNextHop.log.debug('Creating L3UcastRouteNextHop from IDL')
l3nh = L3UnicastNextHop(ni, addr, scp, nh_idl.nextHop.ec,
nh_idl.nextHop.metric)
if nh_idl.nextHop.route_tag is not None:
l3nh._route_tag = nh_idl.nextHop.route_tag
return l3nh
def _to_idl(self):
addr_idl = None
if self._address != None:
addr_idl = NetworkInterface._convert_to_networkaddressidl(
self._address)
if self._network_interface == None:
network_interface_name = None
network_interface_handle = 0
network_interface_type = 0
else:
network_interface_name = self._network_interface.name
network_interface_handle = self._network_interface.xos_handle
network_interface_type = self._network_interface.interface_type
if self._metric is not None:
nh_metric = self._metric
else:
nh_metric = 0
nh_idl = RouteNextHopIDL(network_interface_name, addr_idl,
network_interface_handle,
network_interface_type, 0, nh_metric,
self._route_tag)
self.log.info('Creating RouteNextHopIDL')
scope_idl = None
if self._scope != None and isinstance(self._scope, (L3UnicastScope, )):
scope_idl = self._scope._to_idl()
l3nh_idl = L3UcastRouteNextHopIDL(nh_idl, 0, scope_idl)
self.log.info('Creating L3UcastRouteNextHopIDL')
return l3nh_idl
def _to_idl(self):
prefix_idl = None
addr_idl = None
if self._start_prefix is not None:
addr_idl = NetworkInterface._convert_to_networkaddressidl(
self._start_prefix.address)
prefix_idl = NetworkPrefixIDL(self._start_prefix.prefix_length,
addr_idl)
return L3UcastRouteRangeIDL(self._range_type, self._count, prefix_idl)
def _from_idl(node_idl, node_type):
if node_idl is None or node_type is None:
return
node_name = node_idl.hostname
addr_list = list()
na_list = node_idl.addrlist
if na_list != None:
for na in na_list:
inet_addr = NetworkInterface._convert_to_inetaddress(na)
if inet_addr != None:
addr_list.append(inet_addr)
return Node(node_name, node_type, addr_list)
def OnepEvent_InterfaceStatisticsEventIDL(self, sessionHandle, eventHandle, xosHandle, intfType, parameter, isIncrement, isExitEvent, value, deltaValue, shortName):
"""
For internal use only
"""
tmp = 'Interface Statistics change event received:\n event Handle ' + str(eventHandle)
tmp += '\n xos handle = ' + str(xosHandle) + '\n interface type = ' + str(intfType)
tmp += '\n short name = ' + str(shortName) + ' isIncrement ' + str(isIncrement) + ' value ' + str(value)
tmp += '\ndeltaValue' + str(deltaValue) + '\nisExitevent ' + str(isExitEvent)
self.log.debug(tmp)
ni = NetworkInterface(self.element, shortName, intfType, xosHandle)
event = InterfaceStatisticsEvent(self.element, eventHandle, ni, parameter, isIncrement, value, deltaValue, isExitEvent)
self.enque(event)
def OnepEvent_InterfaceCreateDeleteEventIDL(self, sessionHandle, eventHandle, intfXosHandle, intfName, intfType, isCreated, isOir):
"""
For internal use only
"""
self.log.debug('InterfaceCreateDeleteEventIDL: session Handle = ' + str(sessionHandle) + ' eventHandle = ' + str(eventHandle) + ' interface name = ' + str(intfName) + ' intefaceType' + str(intfType) + ' xos Handle = ' + str(intfXosHandle) + ' isCreated =' + str(isCreated))
if self.terminated:
return
try:
ni = NetworkInterface(self.element, intfName, intfType, intfXosHandle)
event = InterfaceCreateDeleteEvent(self.element, eventHandle, ni, isCreated, isOir)
self.enque(event)
except OnepIllegalArgumentException as e:
self.log.error('AL to PL enum conversion failed')
def OnepEvent_InterfaceStatisticsPollEventIDL(self, sessionHandle, eventHandle, intfXosHandle, intfName, intfType, intfstats):
"""
For internal use only
"""
if self.terminated:
return
try:
self.log.debug('InterfaceStatisticsPollEvent: session Handle = ' + str(sessionHandle) + ' eventHandle = ' + str(eventHandle) + ' interface name = ' + str(intfName) + ' intefaceType = ' + str(intfType) + ' xos Handle = ' + str(intfXosHandle))
ni = NetworkInterface(self.element, intfName, intfType, intfXosHandle)
event = InterfaceStatisticsPollEvent(self.element, eventHandle, ni, intfstats)
self.enque(event)
except OnepIllegalArgumentException as e:
self.log.error('AL to PL conversion failed')
def OnepEvent_cdpEventIDL(self, sessionHandle, eventHandle, xosHandle, name, type_, notifyType, neighborName, holdTime, mgmtDomain, platform, version, capabilities, addresses, neighborIntfName):
"""
For internal use only
"""
self.log.debug('cdp EventIDL: session Handle = ' + str(sessionHandle) + ' eventHandle = ' + str(eventHandle) + ' NetworkInterface = ' + str(name) + ' notifyType = ' + str(notifyType) + ' neighbor = ' + str(neighborName) + 'hold time = ' + str(holdTime) + 'vtp domain = ' + str(mgmtDomain) + 'platform = ' + str(platform) + 'version = ' + str(version) + 'capabilitites = ' + str(capabilities) + 'neighborIntfName = ' + str(neighborIntfName))
if self.terminated:
return
event = None
try:
interface = NetworkInterface(self.element, name, type_, xosHandle)
event = CDPEvent(self.element, eventHandle, interface, notifyType, neighborName, holdTime, mgmtDomain, platform, version, capabilities, addresses, neighborIntfName)
self.enque(event)
except OnepIllegalArgumentException as e:
self.log.error('AL to PL enum conversion failed : ' + str(e.message))
def OnepEvent_InterfaceStateEventIDL(self, sessionHandle, eventHandle, xosHandle, intfType, stateType, intfState, shortName, link = None, lineproto = None):
"""
For internal use only
"""
tmp = 'Interface State change event received:\n event Handle ' + str(eventHandle)
tmp += '\n xos handle = ' + str(xosHandle) + '\n interface type = ' + str(intfType)
tmp += '\n event type = ' + str(stateType) + '\n interface state type = ' + str(intfState)
tmp += '\n short name = ' + str(shortName)
tmp += '\n link state type = ' + str(link) + '\n lineproto state type = ' + str(lineproto)
self.log.debug(tmp)
try:
ni = NetworkInterface(self.element, shortName, intfType, xosHandle)
event = InterfaceStateEvent(self.element, eventHandle, ni, stateType, intfState, link, lineproto)
self.enque(event)
except Exception as e1:
self.log.error('AL to PL enum conversion failed')
def OnepEvent_InterfaceBandwidthEventIDL(self, sessionHandle, eventHandle, xosHandle, intfType, intfName, bandwidth, is_tx = None):
"""
For internal use only
"""
msg = 'InterfaceBandwidthEventIDL: session Handle = ' + str(sessionHandle) + ' eventHandle = ' + str(eventHandle)
msg += ' xosHandle = ' + str(xosHandle) + ' intfType= ' + str(intfType)
msg += ' shortName = ' + intfName + ' Bandwidth = ' + str(bandwidth) + ' Is TX = ' + str(is_tx)
self.log.debug(msg)
if self.terminated:
return
try:
ni = NetworkInterface(self.element, intfName, intfType, xosHandle)
event = InterfaceBandwidthEvent(self.element, eventHandle, ni, bandwidth, is_tx)
self.enque(event)
except OnepIllegalArgumentException as e:
self.log.error('AL to PL enum conversion failed')
def _from_out_idl(node_out_idl, node_type):
"""
Convert TopologyNodeOutIDL to Node object
This method for internal use only
@param node_out_idl: TopologyNodeOutIDL object
@param node_type: NodeType node type
@return: Node object
"""
if node_out_idl == None or node_type == None:
return
node_name = node_out_idl.hostname
addr_list = list()
na_list = node_out_idl.addrlist
if na_list != None:
for na in na_list:
inet_addr = NetworkInterface._convert_to_inetaddress(na)
if inet_addr != None:
addr_list.append(inet_addr)
return Node(node_name, node_type, addr_list)
def _from_idl(route_idl, ne):
if route_idl == None:
return
nh_set = set()
for nh_idl in route_idl.hopList:
if nh_idl != None:
nh_set.add(L3UnicastNextHop._from_idl(nh_idl, ne))
prefix = None
addr = None
if route_idl.prefix != None and route_idl.prefix.addr != None:
if isinstance(route_idl, L3UcastRouteIDL):
addr = NetworkInterface._convert_to_inetaddress(
route_idl.prefix.addr)
elif isinstance(route_idl, L3UcastRouteOutIDL):
addr = route_idl.prefix.addr.addr
prefix = NetworkPrefix(addr, route_idl.prefix.prefix_len)
return L3UnicastRoute(prefix, nh_set, route_idl.ownerType,
route_idl.tag, route_idl.l3UcastRouteType,
route_idl.route.adminDistance,
route_idl.route.metric, route_idl.route.ec)
def _from_idl(connector_idl, connector_type, node):
"""
Convert a TopologyConnectorIDL object to NodeConnector.
This method is for internal use only.
@param connector_idl: TopologyConnectorIDL object.
@param connector_type: ConnectorType object
@param node: associated node
@return: A NodeConnector object
"""
if connector_idl == None or connector_type == None:
return
node_name = connector_idl.connname
addr_list = []
na_list = connector_idl.addrlist
if na_list != None:
for na in na_list:
inet_addr = NetworkInterface._convert_to_inetaddress(na)
if inet_addr != None:
addr_list.append(inet_addr)
return NodeConnector(node_name, connector_type, node, addr_list)
def _to_idl(self):
prefix_idl = None
if self._prefix != None:
addr_idl = NetworkInterface._convert_to_networkaddressidl(
self._prefix.address)
prefix_idl = NetworkPrefixIDL(self._prefix.prefix_length, addr_idl)
self.log.info('Creating NetworkprefixIDL')
r_idl = RouteIDL(0, 0, 0)
r_idl.adminDistance = self._admin_distance
r_idl.metric = self._metric
hop_id_list = list()
if self._next_hop_list != None:
for hop in self._next_hop_list:
if hop != None:
hop_id_list.append(hop._to_idl())
self.log.info('Creating L3UcastRouteIDL')
if self._route_type == None:
self._route_type = 0
if self._owner_type == None:
self._owner_type = 0
return L3UcastRouteIDL(r_idl, self._route_type, self._owner_type,
self._owner_tag, prefix_idl, hop_id_list)
def OnepEvent_InterfaceAddrChangeEventIDL(self, sessionHandle, eventHandle, intfXosHandle, intfName, intfType, oldAddress, newAddress, oldPrefix, newPrefix):
"""
For internal use only
"""
if self.terminated:
return
try:
if oldPrefix == None or newPrefix == None:
oaddr_string = oldAddress
naddr_string = newAddress
oldPrefixLen = 0
newPrefixLen = 0
else:
oaddr_string = oldPrefix.addr
naddr_string = newPrefix.addr
oldPrefixLen = oldPrefix.prefix_len
newPrefixLen = newPrefix.prefix_len
self.log.debug('InterfaceAddressChangeEventIDL: session Handle = ' + str(sessionHandle) + ' eventHandle = ' + str(eventHandle) + ' interface name = ' + str(intfName) + ' intefaceType = ' + str(intfType) + ' xos Handle = ' + str(intfXosHandle) + ' oldAddress = ' + str(oaddr_string) + ' newAddress = ' + str(naddr_string))
ni = NetworkInterface(self.element, intfName, intfType, intfXosHandle)
event = InterfaceAddressChangeEvent(self.element, eventHandle, ni, oaddr_string, naddr_string, oldPrefixLen, newPrefixLen)
self.enque(event)
except OnepIllegalArgumentException as e:
self.log.error('AL to PL enum conversion failed')
def authenticate(self, list_):
"""
Authenticate a user using the AAA Service on the Network Element.
This method authenticates a user (i.e. an instance of AAA User)
using the AAA Service on the Network Element associated with the user
set while creating the AAA User instance
or updated using set_network_element(NetworkElement).
On successful authentication the following will happen:
- The user's authorization profile configured on the AAA server is
returned as a AAA Attribute List instance.
- Accounting is turned on for the user, if the AAA Server
administrator has enabled auto-accounting for this user by
configuring Cisco VSA "auto-acct=enable" in the user's authorization
profile.
The AAA User Authorization Profile is realized using a list of L{onep.aaa.Attribute}
structure, which is cached locally in the AAA User instance.
Change of Authorization functionality is not available,
so if the AAA admin changes the user's profile on the AAA server after
the user was successfully authenticated, the new profile will not
be reflected in this object unless the Application calls
authenticate() again to refresh the Authorization Profile.
Note:
Accounting, if enabled, is turned off when the AAA User instance
is removed using remove_user() or if the AAA User's
Network Element attachment is changed using
set_network_element(NetworkElement) API
Note:
The AAA Server that was used to service this request
can be retrieved from self.server
Note:
The "allowed-action" attribute is not returned in the authorization
profile. Use is_action_authorized(String) to read the
value of this attribute set in the authorization profile configured
on the AAA server.
Example:
>>> attrs = user.authenticate(None)
>>> for attr in attrs:
print str(attr)
@return: List of Attributes containing the authorization profile for the user.
If no authorization profile is configured on AAA server, the list is a size of 0.
@raise OnepConnectionException:
The exception is thrown when connection to a network element has failed
@raise OnepRemoteProcedureException:
The exception is thrown when error has occurred in the remote-
procedure call made to a network element
"""
attrType = None
attr = None
attrName = None
format = AttrFormat_e()
idlList = self.AttrListToIDL(list_)
try:
self._validate_element_connection()
except OnepException:
raise
try:
result = self.user_client.authenticate_IDL(
self.network_element.session_handle._id, self.username,
self.password, idlList)
self.userID = result.aaa_user_id
self.is_auto_acct_enabled = True if result.auto_acct_enabled != 0 else False
try:
address = NetworkInterface._convert_to_inetaddress(
result.server.address)
self.server = Server(
address,
Server.OnepAAAProtocol.enumval(result.server.aaa_protocol))
except OnepIllegalArgumentException as e2:
self.log.error(
'User authenticate: error retrieving server information')
for attrIDL in result.author_profile:
skipResultList = False
attr = None
attrName = None
format = attrIDL.format
try:
attrType = attrIDL.type
except OnepIllegalArgumentException as e1:
self.log.error('Error adding attribute type ' +
str(attrIDL.type) +
' to list, possible enum mismatch')
continue
if attrIDL.type == OnepAAAAttributeType.ONEP_AAA_AT_ALLOWED_APP or attrIDL.type == OnepAAAAttributeType.ONEP_AAA_AT_ALLOWED_ACTION or attrIDL.type == OnepAAAAttributeType.ONEP_AAA_AT_AUTO_ACCT:
skipResultList = True
if attrIDL.type == OnepAAAAttributeType.ONEP_AAA_AT_APP_ATTR:
appAttrValue = attrIDL.str_value
if appAttrValue.startswith('"') and appAttrValue.endswith(
'"'):
appAttrValue = appAttrValue.substring[1:-1]
appValue = appAttrValue.split(':')
if len(appValue) < 3:
self.log.error('Invalid app attribute format')
continue
attrName = appValue[0]
try:
if appValue[1].lower() == 'string':
attr = StringAttribute(attrType, attrName,
appValue[2])
else:
attr = IntAttribute(attrType, attrName,
int(appValue[2]))
except OnepIllegalArgumentException as e:
self.log.error(
'Error adding a Application attribute type ' +
str(appValue))
continue
elif format == AttrFormat_e.AAA_TYPE_FORMAT_ULONG:
try:
attr = IntAttribute(attrType, None,
attrIDL.ulong_value)
except OnepIllegalArgumentException as e:
self.log.error('Error adding attribute type ' +
str(attrType))
continue
elif format == AttrFormat_e.AAA_TYPE_FORMAT_STRING:
try:
attr = StringAttribute(attrType, None,
attrIDL.str_value)
except OnepIllegalArgumentException as e:
self.log.error('Error adding attribute type ' +
str(attrType))
continue
elif format == AttrFormat_e.AAA_TYPE_FORMAT_BINARY:
try:
attr = BinaryAttribute(attrType, None,
attrIDL.binary_value)
except OnepIllegalArgumentException as e:
self.log.error('Error adding attribute type ' +
str(attrType))
continue
else:
try:
attr = AddressAttribute(attrType, None,
attrIDL.str_value)
except OnepIllegalArgumentException as e:
self.log.error('Error adding attribute type ' +
str(attrType))
continue
self.attr_original.append(attr)
if not skipResultList:
self.auth_profile.append(attr)
except ExceptionIDL as e:
raise OnepRemoteProcedureException(e)
except TException as e:
raise OnepConnectionException(arg_cause=e)
return self.auth_profile
