def __cmp__(self, other):
"""
the function is used for comparation, the compared sequence is defined in TLV definition.
:param other: the object who has the IpAddrType, GroupIpAddr, SrcIpAddr, SessionId
:return:
"""
if not hasattr(other, "IpAddrType"):
return 0
if self.IpAddrType != other.IpAddrType:
return self.IpAddrType.__cmp__(other.IpAddrType)
if not hasattr(other, "GroupIpAddr"):
return 0
if self.GroupIpAddr != other.GroupIpAddr:
return Convert.compare_ip(self.GroupIpAddr, other.GroupIpAddr)
if not hasattr(other, "SrcIpAddr"):
return 0
if self.SrcIpAddr != other.SrcIpAddr:
return Convert.compare_ip(self.SrcIpAddr, other.SrcIpAddr)
if not hasattr(other, "SessionId"):
return 0
return self.SessionId.__cmp__(other.SessionId)
def __cmp__(self, other):
if not hasattr(other, "sessionIpAddrType"):
return 0
if self.sessionIpAddrType != other.sessionIpAddrType:
return self.sessionIpAddrType.__cmp__(other.sessionIpAddrType)
if not hasattr(other, "ccapLcceIpAddr"):
return 0
if self.ccapLcceIpAddr != other.ccapLcceIpAddr:
return Convert.compare_ip(self.ccapLcceIpAddr,
other.ccapLcceIpAddr)
if not hasattr(other, "rpdLcceIpAddr"):
return 0
if self.rpdLcceIpAddr != other.rpdLcceIpAddr:
return Convert.compare_ip(self.rpdLcceIpAddr,
other.rpdLcceIpAddr)
if not hasattr(other, "direction"):
return 0
if self.direction != other.direction:
return self.direction.__cmp__(other.direction)
if not hasattr(other, "l2tpSessionId"):
return 0
if self.l2tpSessionId != other.l2tpSessionId:
return self.l2tpSessionId.__cmp__(other.l2tpSessionId)
return 0
def add_ccap_cores(self,
ccap_cores,
port_master=GCPSessionDescriptor.DEFAULT_PORT_MASTER):
"""Create GCP descriptors based on addresses of CCAP cores received
from DHCP server to orchestrator.
:param ccap_cores: list of "interface;core ip"
:type ccap_cores: list(string)
:return:
"""
descriptors = []
for core_addr in ccap_cores:
interface, core = core_addr.split(';')
if not Convert.is_valid_ip_address(core):
self.logger.warn("Malformed IP address received: %s", core)
continue
is_ipv6 = Convert.is_valid_ipv6_address(core)
family = (AF_INET, AF_INET6)[is_ipv6]
addr_local = SysTools.get_ip_address(str(interface), family)
# TODO pass also local address to use specific interface
descriptors.append(
GCPSlaveDescriptor(core,
port_master=port_master,
addr_local=addr_local,
interface_local=interface,
addr_family=family))
self.orchestrator.add_sessions(descriptors)
def __init__(self, localAddr, connID):
"""Init the L2TP socket and bind to it.
:param localAddr: The local IP address that we want to bind L2TP socket to it.
:param connID: The connection ID, in L2tpv3 domain, it means the lcoal connection ID.
"""
self.socket = None
self.addr = localAddr
self.connID = connID
if Convert.is_valid_ipv4_address(localAddr):
self.socket = socket.socket(
socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_L2TP)
self.socket.setblocking(False) # Set the socket to non-block mode
self.socket.bind((localAddr, connID))
self.logger.info(
"Create L2TP socket and bind to it, local IP address:%s, local Connection ID:%d, socket: %d" %
(localAddr, connID, self.socket.fileno()))
elif Convert.is_valid_ipv6_address(localAddr):
self.socket = socket.socket(
socket.AF_INET6, socket.SOCK_DGRAM, socket.IPPROTO_L2TP)
self.socket.setblocking(False) # Set the socket to non-block mode
self.socket.bind(('', connID))
self.logger.info(
"Create L2TP socket and bind to any adress, local Connection ID:%d, socket: %d" %
(connID, self.socket.fileno()))
else:
self.logger.info(
"Create L2TP socket failed, invalid local IP address:%s, local Connection ID:%d" %
(localAddr, connID))
self.socket = None
def _to_gpb_value(self, value):
"""Converts the value into the GPB representation according to
format."""
if self.format.value_is_mac():
return Convert.bytes_to_mac_str(value)
if self.format.value_is_ip_addr():
return Convert.bytes_to_ip_addr(value)
return value
def test_compip(self):
ret = Convert.compare_ip("10.79.41.31", "10.79.41.31")
self.assertEquals(ret, 0)
ret = Convert.compare_ip("10.79.41.30", "10.79.41.31")
self.assertEquals(ret, -1)
ret = Convert.compare_ip("10.79.41.30", "10.25.41.31")
self.assertEquals(ret, 1)
ret = Convert.compare_ip("fe80::6a5b:35ff:feb2:8dcf",
"fe80::6a5b:35ff:feb2:8d6f")
self.assertEquals(ret, 1)
def _from_gpb_value(self, value):
"""Translates value from GPB's representation into the internal
representation suitable for encoding."""
if self.format.format_str == DataDescription.MAC_FMT:
return Convert.mac_to_tuple_of_bytes(value)
elif self.format.format_str == DataDescription.IP_FMT:
return Convert.ipaddr_to_tuple_of_bytes(value)
elif isinstance(value, unicode):
return str(value)
return value
def test_IP_positive(self):
ip4_str = "1.2.3.4"
ip4_tuple = (0x1, 0x2, 0x3, 0x4)
self.assertEqual(Convert.ipaddr_to_tuple_of_bytes(ip4_str), ip4_tuple)
ip6_str = '1111::2222'
ip6_tuple = (0x11, 0x11, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x22, 0x22)
self.assertEqual(Convert.ipaddr_to_tuple_of_bytes(ip6_str), ip6_tuple)
ip6_str = '::'
ip6_tuple = (0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0)
self.assertEqual(Convert.ipaddr_to_tuple_of_bytes(ip6_str), ip6_tuple)
def upload_with_tftp(self, crashFileCtrlInfo, crashDataServerInfo):
"""
upload the crash file in tftp mode
:param tftp_options:
:param crashFileCtrlInfo:
:return:
"""
tftp_options = {}
if Convert.is_valid_ipv4_address(str(crashDataServerInfo.destIpAddress)):
blksize = 1042
tftp_options['blksize'] = int(blksize)
elif Convert.is_valid_ipv6_address(str(crashDataServerInfo.destIpAddress)):
blksize = 1048
tftp_options['blksize'] = int(blksize)
fileName = crashFileCtrlInfo.fileName
if crashDataServerInfo.destPath.endswith('/'):
destFileName = crashDataServerInfo.destPath + fileName
else:
destFileName = crashDataServerInfo.destPath + '/' + fileName
srcFileName = CrashFileCtrlHandler.CORE_FILE_PATH + fileName
self.logger.debug("Tftp upload destFileName:%s srcFileName:%s destIpAddress:%s" %
(destFileName, srcFileName, crashDataServerInfo.destIpAddress))
try:
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_UPLOADINPROGRESS,
crashFileCtrlInfo)
tclient = tftpy.TftpClient(crashDataServerInfo.destIpAddress, int(self.TFTP_PORT),
tftp_options)
tclient.upload(str(destFileName), str(srcFileName))
self.logger.debug("tftp upload %s complete", srcFileName)
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_UPLOADCOMPLETED,
crashFileCtrlInfo)
except TftpTimeout as err:
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_ERROR,
crashFileCtrlInfo)
self.logger.warn(
"Error: File {0:s} fail to upload with TftpException {1:s}"
.format(fileName, str(err)))
except TftpException as err:
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_ERROR,
crashFileCtrlInfo)
self.logger.warn("Error: File %s fail to upload with TftpException %s" %
(fileName, str(err)))
except Exception as err:
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_ERROR,
crashFileCtrlInfo)
self.logger.warn("Error: File %s fail to upload with TftpException %s" %
(fileName, str(err)))
if tclient.context is not None:
tclient.context.end()
def _is_valid(self, value, name):
try:
fmt = self.rcptlv.child_dict_by_name[name]
if fmt.value_is_mac():
value = Convert.mac_to_tuple_of_bytes(value)
elif fmt.value_is_ip_addr():
value = Convert.ipaddr_to_tuple_of_bytes(value)
fmt.validate(value)
return True
except GCPInvalidDataValueError:
return False
except ValueError:
return False
except TypeError:
return False
def _verify_dhcp_data(self):
"""Verify data from msg sent by DHCP client. Invalid or bad formatted
data are removed.
:return:
"""
for descr, value in self.dhcp_data.ListFields():
self.logger.info("%s = %s", descr.name, str(value))
if descr.name in ['CCAPCores', 'LogServers', 'TimeServers']:
# Walk list of IP addresses and check one-by-one
for ip_addr in value[:]:
# Remove all invalid values
if not Convert.is_valid_ip_address(ip_addr):
self.logger.warn(
"Unexpected format of value: "
"%s = %s", descr.name, ip_addr)
value.remove(ip_addr)
elif descr.name == 'TimeOffset':
# Nothing to be checked (int32)
pass
else:
self.logger.error("Unknown value found: %s", descr.name)
self.store_dhcp_data()
def _get_specific_core_para(rcp_msg, args):
try:
interface_local = None
ccap_core_ip = None
if rcp_msg.RcpMessageType in [
t_RcpMessage.CONNECT_CLOSE_NOTIFICATION,
t_RcpMessage.SESSION_INITIATED,
t_RcpMessage.REDIRECT_NOTIFICATION
]:
core_para = json.loads(rcp_msg.parameter)
ccap_core_ip = core_para[
'addr_remote'] if None is not core_para[
'addr_remote'] else ''
interface_local = core_para[
'interface_local'] if None is not core_para[
'interface_local'] else ''
elif rcp_msg.RcpMessageType in [
t_RcpMessage.RPD_CONFIGURATION,
t_RcpMessage.RPD_CONFIGURATION_DONE,
t_RcpMessage.IRA_RECEIVED, t_RcpMessage.REX_RECEIVED
]:
if args:
session, transaction_identifier, trans_id = args
interface_local = session.get_descriptor().interface_local
ccap_core_ip = Convert.format_ip(
session.get_descriptor().addr_remote)
specific = (interface_local, ccap_core_ip)
return specific
except Exception as e:
return None
def get_gcp_info(self, args=None):
"""
:return: gcp info
"""
gcp_info = []
try:
agent_id = ProcessAgent.AGENTTYPE_GCP
for ccap_core_id in CCAPCore.ccap_core_db:
ccap_core = CCAPCore.ccap_core_db[ccap_core_id]
status = ccap_core.agent_status[agent_id]
para = ccap_core.parameters
principal = ccap_core.is_principal
is_ipv6 = Convert.is_valid_ipv6_address(ccap_core.ccap_core_network_address)
family = (socket.AF_INET, socket.AF_INET6)[is_ipv6]
if agent_id in para and ';' in para[agent_id]:
intf, core_ip = para[agent_id].split(';')
local_ip = SysTools.get_ip_address(str(intf), family=family)
value = {
"Core-ID": ccap_core_id, "Core-IP": core_ip, "Local-IP": local_ip,
"Principal": 'Yes' if principal == CoreDescription.CORE_ROLE_PRINCIPAL else 'No',
'Status': status}
gcp_info.append(value)
return True, gcp_info
except Exception as e:
return False, str(e)
def get_dhcp_info(self, args=None):
"""
:return: dhcp info
"""
dhcp_info = {'Interface': [], 'Details': []}
try:
nic_info = net_if_addrs()
for intf in self.mgr.dhcp_parameter:
netmask = '0.0.0.0'
is_ipv6 = Convert.is_valid_ipv6_address(self.mgr.dhcp_parameter[intf]['CCAPCores'][0])
family = (socket.AF_INET, socket.AF_INET6)[is_ipv6]
for item in nic_info[intf]:
if item.family == family:
netmask = item.netmask
break
local_ip = SysTools.get_ip_address(str(intf), family=family)
value = {"Interface": intf, 'IP-Address': local_ip, "Subnet-Mask": netmask}
dhcp_info['Interface'].append(value)
addr_type = "IPv4"
if is_ipv6:
if self.mgr.dhcp_parameter[intf]['Slaac']:
addr_type = "IPv6<Stateless>"
else:
addr_type = "IPv6<Stateful>"
intf_dhcp_parameter = self.mgr.dhcp_parameter[intf]
intf_dhcp_parameter["AddrType"] = addr_type
dhcp_info['Details'].append((intf, intf_dhcp_parameter))
return True, dhcp_info
except Exception as e:
return False, str(e)
def config_rsyslog(self, address):
"""Set address of remote log server,support rsyslog.
- For now only one log-server(rsyslog) is supported (TCP is used)
:param address: rsyslog server IP address (v4 or v6) or None to
disable remotelogging feature
:param logging_level: string or None
:param rotate_size: rotatation size for log file
:return:
"""
if None is address:
# disable remote logging feature
# restart rsyslog
self.restart_rsyslog()
return
if not Convert.is_valid_ip_address(address):
self.logger.warning(
"Invalid IP address provided for remote logging: %s", address)
return
try:
# enable remote logging feature
self.config_rsyslog_remote(address)
# restart rsyslogd
self.restart_rsyslog()
except (OSError, ValueError):
self.logger.error("Failed remote logging configuration")
def connect(self, ipv4_addr):
"""Creates socket and connects it to the IT API server identified by
IPv4 address.
:param ipv4_addr: IPv4 address of the IT API server's interface.
:type ipv4_addr: String
:returns: True if connected successfully, False otherwise.
"""
if None is ipv4_addr:
raise AttributeError("No IPv4 address of server passed")
if not Convert.is_valid_ipv4_address(ipv4_addr):
self.logger.error("Invalid IPv4 address passed: %s", ipv4_addr)
return False
port = DEFAULT_IT_API_PORT
self.logger.debug("Openning socket and connecting to server: %s:%s",
ipv4_addr, port)
ctx = zmq.Context.instance()
self.it_api_socket = ctx.socket(zmq.REQ)
self.it_api_socket.connect("tcp://{}:{}".format(ipv4_addr, port))
self.logger.info("Connected to IT API server: %s:%s", ipv4_addr, port)
return True
def update_mcast_session_to_db(self, session):
"""
:param session: (local_ip, remote_ip, local_session, remote_session)
:return:
"""
try:
local_ip, remote_ip, local_session, remote_session, = session
record = DepiMcastSessionRecord()
record.updateDepiMcastSessionKey(
IpAddrType=DepiMcastSessionRecord.get_inetaddr_type(
self.grp_ip),
GroupIpAddr=self.grp_ip,
SrcIpAddr=self.src_ip,
SessionId=local_session)
record.updateDepiMcastSessionData(
LocalLcceIpAddr=local_ip,
RemoteLcceIpAddr=remote_ip,
JoinTime=Convert.pack_timestamp_to_string(self.lastchange))
record.write()
except Exception as e:
self.logger.warning(
"%s failed to update ses:%s into db for exception %s",
str(self), str(session), str(e))
def create_ipv4_ipv6_record(self, test_count=1000):
sessRec = DepiMcastSessionRecord()
print "#########: write %s session in db." % (test_count * 2)
current_time = time.time()
print "current time is: " + str(
datetime.datetime.fromtimestamp(current_time))
for test_session in range(0, test_count):
sessRec.updateDepiMcastSessionKey(IpAddrType=1,
GroupIpAddr="10.79.31.1",
SrcIpAddr="10.90.31.1",
SessionId=test_session + 1)
test_time = Convert.pack_timestamp_to_string(time.time())
sessRec.updateDepiMcastSessionData("10.1.1.1", "1.1.1.1",
time.time())
sessRec.write()
sessRec.updateDepiMcastSessionKey(IpAddrType=2,
GroupIpAddr="2001::1",
SrcIpAddr="2001::2",
SessionId=test_session + 1)
sessRec.updateDepiMcastSessionData("2001::1", "2001::1", test_time)
sessRec.write()
current_time = time.time()
print "end time is: " + str(
datetime.datetime.fromtimestamp(current_time))
return True
def read_ipv6_scope(interface, ip):
scope = 11 # unknown scope
ipv6_info = open("/proc/net/if_inet6", "r").readlines()
for info in ipv6_info:
if interface in info:
if_ip = Convert.format_proc_address(info.split(' ')[0])
if if_ip == ip:
scope = int(info.split(' ')[3])
return scope
def test_MAC_negative(self):
self.assertIsNone(Convert.mac_to_tuple_of_bytes(1))
self.assertIsNone(Convert.mac_to_tuple_of_bytes(""))
self.assertIsNone(Convert.mac_to_tuple_of_bytes("11:"))
self.assertIsNone(Convert.mac_to_tuple_of_bytes("01:02:03:04:05"))
self.assertIsNone(Convert.mac_to_tuple_of_bytes("GG:02:03:04:05:06"))
self.assertIsNone(Convert.mac_to_tuple_of_bytes("125:02:03:04:05"))
def change_eth1_ip_addr(self, ip_addr):
"""Change IP address on eth1 NOTE: Do not forget to restart services if
already running.
:param ip_addr: IP address to be assigned to eth1 interface. In format:
1.2.3.4. This is applicable only for 'external' images.
RPD image requires DHCP managed eth1 interface. Support for mask and
gateway change can be added in the future.
:return:
"""
if not Convert.is_valid_ip_address(ip_addr):
raise TypeError("Invalid IP address string provided: %s", ip_addr)
is_ipv4 = Convert.is_valid_ipv4_address(ip_addr)
if is_ipv4:
self.ip_addresses = (self.ip_addresses[0], ip_addr)
net_name = 'lan'
else:
self.ipv6_addresses = (self.ipv6_addresses[0], ip_addr)
net_name = 'lanV6'
# Check if protocol on eth1 is set to static (truth only on external)
try:
proto = self.run_command(
"uci show network.{}.proto".format(net_name))
if proto[0].strip().split('=')[1] != '\'static\'':
raise TypeError("IP address is not static - not server side?")
# Configure IP address provided
if is_ipv4:
cmd = "uci set network.{net}.ipaddr={ip_addr}; "
else:
cmd = "uci set network.{net}.ip6addr={ip_addr}/64; "
# Commit changes to network configuration
cmd += "uci commit network; "
# Apply config to interface
cmd += "ifup {net}"
self.run_command(cmd.format(net=net_name, ip_addr=ip_addr))
except subprocess.CalledProcessError as exception:
self.logger.error(
"Failed to set IP address to host: %s", exception.message)
return
def test_bytes_convert(self):
illegal_var = '01:02:03:192.168.0.1:0a:0b:'
try:
Convert.bytes_to_mac_str(illegal_var)
except TypeError:
pass
else:
self.fail('illegal mac been converted')
try:
Convert.bytes_to_ipv4_str(illegal_var)
except TypeError:
pass
else:
self.fail('illegal ipv4 been converted')
try:
Convert.bytes_to_ipv6_str(illegal_var)
except TypeError:
pass
else:
self.fail('illegal ipv6 been converted')
try:
Convert.bytes_to_ip_addr(illegal_var)
except TypeError:
pass
else:
self.fail('illegal ip been converted')
# try:
ret = Convert.mac_to_tuple_of_bytes('-1:-2:-3:-4:-5')
# except ValueError:
# pass
# else:
# self.fail('illegal mac been converted: %s' % ret)
self.assertIsNone(ret, 'illegal mac been converted: %s' % ret)
self.assertFalse(Convert.is_valid_ipv4_address('a.b.c.d'))
def test_IP_negative(self):
self.assertIsNone(Convert.ipaddr_to_tuple_of_bytes(1))
self.assertIsNone(Convert.ipaddr_to_tuple_of_bytes("1.2.3.4.5"))
self.assertIsNone(Convert.ipaddr_to_tuple_of_bytes(""))
self.assertIsNone(Convert.ipaddr_to_tuple_of_bytes("1.2.3..4"))
self.assertIsNone(Convert.ipaddr_to_tuple_of_bytes("1.2.256.4"))
self.assertIsNone(Convert.ipaddr_to_tuple_of_bytes(":::"))
def getLocalIp(core_ip):
intf = 'eth0'
family = socket.AF_INET
if core_ip is not None:
is_ipv6 = Convert.is_valid_ipv6_address(core_ip)
family = (socket.AF_INET, socket.AF_INET6)[is_ipv6]
if core_ip is None or core_ip == "127.0.0.1" or core_ip == "::1":
intf = 'eth0'
else:
intf = SysTools.get_interface()
local_ip = SysTools.get_ip_address(intf, family)
if local_ip is None:
return globalSettings.L2tpv3GlobalSettings.LocalIPAddress
return local_ip
def test_readwrite(self):
sessRec = DepiMcastSessionRecord()
sessRec.updateDepiMcastSessionKey(IpAddrType=1,
GroupIpAddr="10.79.31.1",
SrcIpAddr="10.79.31.1",
SessionId=1)
self.assertEquals(sessRec.index.IpAddrType, 1)
self.assertEquals(sessRec.index.SrcIpAddr, "10.79.31.1")
self.assertEquals(sessRec.index.SessionId, 1)
sessRec.write()
# get_all
ret = []
for ses in sessRec.get_all():
ret.append(ses)
self.assertEquals(len(ret), 1)
sessRec = None
sessRec = DepiMcastSessionRecord()
sessRec.updateDepiMcastSessionKey(IpAddrType=1,
GroupIpAddr="10.79.31.1",
SrcIpAddr="10.79.31.1",
SessionId=1)
sessRec.read()
self.assertEquals(sessRec.index.IpAddrType, 1)
self.assertEquals(sessRec.index.GroupIpAddr, "10.79.31.1")
self.assertEquals(sessRec.index.SrcIpAddr, "10.79.31.1")
self.assertEquals(sessRec.index.SessionId, 1)
self.assertEquals(sessRec.JoinTime, "")
self.assertEquals(sessRec.LocalLcceIpAddr, "")
self.assertEquals(sessRec.RemoteLcceIpAddr, "")
# modify the property
currtime = Convert.pack_timestamp_to_string(time.time())
sessRec.JoinTime = currtime
sessRec.write()
sessRec.read()
self.assertEquals(sessRec.index.IpAddrType, 1)
self.assertEquals(sessRec.index.GroupIpAddr, "10.79.31.1")
self.assertEquals(sessRec.index.SrcIpAddr, "10.79.31.1")
self.assertEquals(sessRec.index.SessionId, 1)
self.assertEquals(sessRec.JoinTime, currtime)
self.assertEquals(sessRec.LocalLcceIpAddr, "")
self.assertEquals(sessRec.RemoteLcceIpAddr, "")
# get_all
ret = []
for ses in sessRec.get_all():
ret.append(ses)
self.assertEquals(len(ret), 1)
def test_performance(self):
sessRec = DepiMcastSessionRecord()
test_count = 1000
print "#########: perfermance test about %s session in store" % test_count
current_time = time.time()
print "current time is: " + str(
datetime.datetime.fromtimestamp(current_time))
for test_session in range(0, test_count):
sessRec.updateDepiMcastSessionKey(IpAddrType=1,
GroupIpAddr="10.79.31.1",
SrcIpAddr="10.90.31.1",
SessionId=test_session)
test_time = Convert.pack_timestamp_to_string(time.time())
sessRec.updateDepiMcastSessionData("10.1.1.1", "1.1.1.1",
test_time)
sessRec.write()
print "Write " + str(test_count) + " records need : " + str(
time.time() - current_time)
current_time = time.time()
ret = []
for record in sessRec.get_next_n(count=test_count):
ret.append(record)
self.assertEquals(len(ret), test_count)
print "get_next_n " + str(test_count) + " records need : " + str(
time.time() - current_time)
print "current time is: " + str(
datetime.datetime.fromtimestamp(time.time()))
current_time = time.time()
ret = []
for record in sessRec.get_next_n(count=20):
ret.append(record)
self.assertEquals(len(ret), 20)
end_time = time.time()
print "get_next_n " + str(20) + " records need : " + str(end_time -
current_time)
print "End time is: " + str(datetime.datetime.fromtimestamp(end_time))
self.assertEquals(len(ret), 20)
current_time = time.time()
ret = []
for ses in sessRec.get_all():
ret.append(ses)
print "get_next_all " + str(test_count) + " records need : " + str(
time.time() - current_time)
self.assertEquals(len(ret), test_count)
def upload_with_http(self, crashFileCtrlInfo, crashDataServerInfo):
"""
upload the crash file in http mode
:param crashFileCtrlInfo:
:return:
"""
corefilepath = CrashFileCtrlHandler.CORE_FILE_PATH + crashFileCtrlInfo.fileName
self.logger.debug("Upload crash file %s in http mode" % corefilepath)
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_UPLOADINPROGRESS,
crashFileCtrlInfo)
if Convert.is_valid_ipv6_address(
str(crashDataServerInfo.destIpAddress)):
httpServer = "[" + str(crashDataServerInfo.destIpAddress) + "]"
else:
httpServer = str(crashDataServerInfo.destIpAddress)
try:
dataForm = MultiDataForm()
with open(corefilepath, 'rb') as uploadFile:
dataForm.add_file('file', crashFileCtrlInfo.fileName, uploadFile)
if not str(crashDataServerInfo.destPath):
url = 'http://' + httpServer + ':' + str(self.HTTP_PORT)
else:
url = 'http://' + httpServer + ':' + str(self.HTTP_PORT) + \
str(crashDataServerInfo.destPath)
self.logger.info("Http url is %s" % url)
request = urllib2.Request(url)
body = str(dataForm)
request.add_header('Content-type', dataForm.get_content_type())
request.add_header('Content-length', len(body))
request.add_data(body)
urllib2.urlopen(request).read()
self.logger.debug("Http upload %s compplete" % (crashFileCtrlInfo.fileName))
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_UPLOADCOMPLETED,
crashFileCtrlInfo)
except urllib2.HTTPError as e:
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_ERROR,
crashFileCtrlInfo)
self.logger.warn("HTTP Error %s fail to upload: %s" % (corefilepath, str(e)))
except urllib2.URLError as e:
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_ERROR,
crashFileCtrlInfo)
self.logger.error("HTTP Error %s fail to upload: %s" % (corefilepath, str(e)))
except Exception as e:
self.update_crash_file_status(CrashFileCtrlHandler.STATUS_ERROR,
crashFileCtrlInfo)
self.logger.error("HTTP Error %s fail to upload: %s" % (corefilepath, str(e)))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--rpd-image', required=True, action='append')
parser.add_argument('--server-image')
parser.add_argument('--server-addr', help='IP address to be used for eth1')
parser.add_argument('--disable-terminal', action='store_true')
parser.add_argument('--destroy-before',
action='store_true',
help='Destroy all VMs and networks at the beginning')
args = parser.parse_args()
# Check arguments
for image_path in args.rpd_image:
if not os.path.exists(image_path):
parser.error("RPD image file not found: {}".format(image_path))
if args.server_image is not None:
if not os.path.exists(args.server_image):
parser.error("Server image file not found: {}".format(
args.server_image))
if args.server_addr is not None and \
not Convert.is_valid_ip_address(args.server_addr):
parser.error("Server IP address is not valid: {}".format(
args.server_addr))
# Create topology and start VMs
topology = Topology()
if args.destroy_before:
topology.stop_all_force()
if args.server_image is not None:
topology.create_vm(args.server_image, name='server', start=False)
for idx, image_path in enumerate(args.rpd_image):
topology.create_vm(image_path, name='RPD' + str(idx + 1), start=False)
topology.start_and_wait_for_all()
# Assign server address
if None not in (args.server_addr, args.server_image):
topology.nodes['server'].change_eth1_ip_addr(args.server_addr)
# Open terminals or print IP addresses
for node in topology.nodes.values():
if not args.disable_terminal:
node.open_terminal()
else:
print "VM: '{}': '{}'".format(node.name, node.ip_addresses[0])
print "Topology should be ready, press anything to kill it"
raw_input()
# Destroy topology and delete created files
topology.cleanup()
exit(EX_OK)
def test_updateDepiMcastSessionData(self):
sessRec = DepiMcastSessionRecord()
sessRec.updateDepiMcastSessionKey(IpAddrType=1,
GroupIpAddr="10.79.31.1",
SrcIpAddr="10.79.31.1",
SessionId=1)
self.assertEquals(sessRec.index.IpAddrType, 1)
self.assertEquals(sessRec.index.SrcIpAddr, "10.79.31.1")
self.assertEquals(sessRec.index.SessionId, 1)
testIP1 = "127.0.0.1"
testIP2 = "127.0.0.2"
testTime = Convert.pack_timestamp_to_string(time.time())
sessRec.updateDepiMcastSessionData(LocalLcceIpAddr=testIP1,
RemoteLcceIpAddr=testIP2,
JoinTime=testTime)
self.assertEquals(sessRec.LocalLcceIpAddr, testIP1)
self.assertEquals(sessRec.RemoteLcceIpAddr, testIP2)
self.assertEquals(sessRec.JoinTime, testTime)
def learn_arp_us_l2tp_session(self, _):
arp_addr_dict = \
L2tpv3GlobalSettings.L2tpv3GlobalSettings.l2tp_hal_client.arp_addr_dict
try:
if self.pingSocket is None:
self.pingSocket = socket.socket(socket.AF_INET, socket.SOCK_RAW,
socket.getprotobyname("icmp"))
for dest_addr in arp_addr_dict.keys():
addr_family = (socket.AF_INET if Convert.is_valid_ipv4_address(dest_addr)
else socket.AF_INET6)
if addr_family == socket.AF_INET6:
continue
self.pingSocket.sendto(
PingPackage.pack_package(1, PingPackage.ICMP_DATA_STR, False),
(dest_addr, 80))
except Exception as ex:
self.logger.warning("Got exception when send the arp package: %s",
str(ex))
