def create(cls, field, value, recordLength):
checkType('field', (FieldSpecifier,), field)
length = None
struct_ = field.struct_
if(field.variableLength):
if(isinstance(struct_, (TypeBasicList, TypeSubTemplateList))):
length = value._computeLength()
else:
length = len(value)
if(length > 65535): raise Exception('Maximum length(65535) exceeded: %d' % length)
struct_ = getStructForType(field.type, field.name, length=length)
if(struct_ is None):
raise Exception('Undefined struct for FieldSpecifier(%s)' % field.name)
if(field.variableLength):
if(isinstance(struct_, (TypeBasicList, TypeSubTemplateList))):
recordLength[0] += length + (3 if(length > 254) else 1)
else:
recordLength[0] += struct_.size + (3 if(struct_.size > 254) else 1)
else:
recordLength[0] += struct_.size
obj = cls()
obj.field = field
obj.struct_ = struct_
obj.length = length
obj.value = value
if(not isinstance(struct_, (TypeBasicList, TypeSubTemplateList))):
if((field.minValue is not None) and (obj.value < field.minValue)): raise Exception('Underflow value(%s) < minValue(%s) in field(%s)' % (str(obj.value), str(field.minValue), field.name))
if((field.maxValue is not None) and (obj.value > field.maxValue)): raise Exception('Overflow value(%s) > maxValue(%s) in field(%s)' % (str(obj.value), str(field.minValue), field.name))
if((field.choose is not None) and (obj.value not in field.choose)): raise Exception('Invalid choice(%s) in field(%s)' % (str(obj.value), field.name))
return(obj)
def read(cls, field, rawData, domain):
checkType('field', (FieldSpecifier,), field)
obj = cls()
obj.field = field
length = None
struct_ = None
if(field.variableLength):
data = rawData.read(1)
length = FieldValue._strShortLength.unpack_from(data)[0]
if(length == 255):
data = rawData.read(2)
length = FieldValue._strLongLength.unpack_from(data)[0]
struct_ = getStructForType(field.type, field.name, length=length)
else:
if(field.struct_ is None):
raise Exception('Undefined struct for FieldSpecifier(%s)' % field.name)
struct_ = obj.field.struct_
length = struct_.size
data = None
try:
if(isinstance(struct_, (TypeBasicList,))):
from ADT_BasicList import ADT_BasicList
obj.value = ADT_BasicList.read(rawData, length, domain)
elif(isinstance(struct_, (TypeSubTemplateList,))):
from ADT_SubTemplateList import ADT_SubTemplateList
obj.value = ADT_SubTemplateList.read(rawData, length, domain)
else:
data = rawData.read(length)
obj.value = struct_.unpack_from(data)
if(isinstance(obj.value, (tuple,))):
if(obj.field.type=='string'):
obj.value = ''.join(map(str, obj.value)) # convert chars to string
obj.value = obj.value.strip() # remove leading and tailing whitespaces
elif(obj.field.type=='octetArray'):
obj.value = ''.join(map(chr, obj.value)) # convert ascii values to string
except Exception as e:
logger = logging.getLogger(__name__)
if(field.variableLength):
logger.error('Error reading field(%s) with struct(%s) length(%d) rawData(%s)' % (
obj.field.name,
struct_.format if(struct_ is not None) else None,
struct_.size if(struct_ is not None) else length,
binascii.hexlify(data) if(data is not None) else data))
else:
logger.error('Error reading field(%s) with struct(%s) length(%d) rawData(%s)' % (
obj.field.name,
obj.field.struct_.format,
obj.field.struct_.size,
binascii.hexlify(data)))
logger.exception(e)
if(not isinstance(struct_, (TypeBasicList, TypeSubTemplateList))):
if(len(obj.value) == 1): obj.value = obj.value[0]
if((field.minValue is not None) and (obj.value < field.minValue)): raise Exception('Underflow value(%s) < minValue(%s) in field(%s)' % (str(obj.value), str(field.minValue), field.name))
if((field.maxValue is not None) and (obj.value > field.maxValue)): raise Exception('Overflow value(%s) > maxValue(%s) in field(%s)' % (str(obj.value), str(field.minValue), field.name))
if((field.choose is not None) and (obj.value not in field.choose)): raise Exception('Invalid choice(%s) in field(%s)' % (str(obj.value), field.name))
return(obj)
def create(cls, semantic, template):
checkSemantics(semantic)
checkType('template', (TemplateRecord, ), template)
obj = cls()
obj.semantic = semantic
obj.template = template
obj.templateId = template.getId()
return (obj)
def create(cls, semantic, field):
checkSemantics(semantic)
checkType('field', (FieldSpecifier, ), field)
obj = cls()
obj.semantic = semantic
obj.field = field
obj.fieldId = field.getId()
return (obj)
def createFromFile(cls, configFile):
checkType('configFile', (file, ), configFile)
obj = cls()
obj.fileName = configFile.name
obj.data = json.loads(configFile.read())
configFile.close()
obj._validate()
return (obj)
def checkConfiguration(config):
checkType('config', (dict, ), config)
checkIPv4('listenIP', checkAttr('listenIP', config))
checkPort('listenPort', checkAttr('listenPort', config))
transport = checkAttr('transport', config)
checkOptions('transport', transport, ['udp', 'tcp'])
if (transport != 'udp'):
raise Exception('Transport(%s) not implemented' % str(transport))
def writeMessage(self, message, rawData):
from Message import Message
logger = logging.getLogger(__name__)
try:
checkType('message', (Message,), message)
message.write(rawData)
except Exception as e:
logger.exception(e)
return(message)
def checkConfiguration(config):
checkType('config', (dict,), config)
checkIPv4('localIP', checkAttr('localIP', config))
checkIPv4('serverIP', checkAttr('serverIP', config))
checkPort('serverPort', checkAttr('serverPort', config))
transport = checkAttr('transport', config)
checkOptions('transport', transport, ['udp', 'tcp'])
if(transport != 'udp'): raise Exception('Transport(%s) not implemented' % str(transport))
checkFloat('templateRefreshTimeout', checkAttr('templateRefreshTimeout', config), 1, 86400)
def __init__(self, session):
checkType('session', (Session, ), session)
self.__logging = logging.getLogger(__name__)
self.__configured = False
self.__running = False
self.__listenIP = None
self.__listenPort = None
self.__transport = None
self.__session = session
self.__server = None
self.__serverThread = None
def __init__(self, session):
checkType('session', (Session,), session)
self.__configured = False
self.__running = False
self.__session = session
self.__client = None
self.__localIP = None
self.__serverIP = None
self.__serverPort = None
self.__transport = None
self.__templateRefreshTimeout = None
self.__timer = None
def checkJSON(fields):
checkType('fields', (list,), fields)
fields_ = []
idValues = set()
for field in fields:
field_ = FieldSpecifier.newFromJSON(field)
id_ = field_.informationElementId
if(id_ in idValues): raise Exception('Multiple occurrences of id(%d) in template' % id_)
idValues.add(id_)
fields_.append(field_)
return(fields_)
def create(cls, templateId, fields):
checkInteger('templateId', templateId, 1)
checkType('fields', (list,), fields)
for field in fields:
checkType('field', (FieldSpecifier,), field)
obj = cls()
obj.templateId = templateId
obj.fields = fields
obj.fieldCount = len(obj.fields)
return(obj)
def fromJSON(cls, data):
obj = cls()
semantic = checkAttr('semantic', data)
checkSemantics(semantic)
obj.semantic = semantic
template = checkAttr('template', data)
template = TemplateRecord.newFromJSON(template['templateId'],
template['fields'])
checkType('template', (TemplateRecord, ), template)
obj.template = template
obj.templateId = template.getId()
obj.records = map(lambda x: DataRecord.create(template, x['values']),
data['records'])
return (obj)
def create(cls,
session,
observationDomainId,
explicitTimeStamp=None,
version=IPFIX_VERSION):
from Session import Session
checkType('session', (Session, ), session)
if (explicitTimeStamp is not None):
checkType('explicitTimeStamp', (int, long, float),
explicitTimeStamp)
msg = cls()
msg.session = session
msg.exportTimeUTC = time.gmtime(explicitTimeStamp)
msg.version = version
msg.observationDomainId = observationDomainId
return (msg)
def createDataSet(cls, domain, setId):
checkType('domain', (ObservationDomain, ), domain)
checkInteger('setId', setId)
if ((setId == 0) or (setId == 1)):
raise Exception('Unusable SetId(%d)' % setId)
if (setId == 2):
raise Exception('SetId(%d) can only be used in TemplateSets' %
setId)
if (setId == 3):
raise Exception(
'SetId(%d) can only be used in OptionTemplateSets' % setId)
if ((setId >= 4) and (setId <= 255)):
raise Exception('Reserved SetId(%d)' % setId)
if (not domain.hasExporterTemplate(setId)):
raise Exception(
'Domain(%d) does not contain Exporter Template(%d)' %
(domain.obsDomainId, setId))
obj = cls()
obj.setId = setId
obj.setType = 'data'
return (obj)
def checkConfiguration(config):
checkType('config', (dict, ), config)
if (('localIP' in config) and (config['localIP'] is not None)):
checkIPv4('localIP', config['localIP'])
if (('serverIP' in config) and (config['serverIP'] is not None)):
checkIPv4('serverIP', config['serverIP'])
if (('serverPort' in config) and (config['serverPort'] is not None)):
checkPort('serverPort', config['serverPort'])
if (('transport' in config) and (config['transport'] is not None)):
checkOptions('transport', config['transport'], ['udp', 'tcp'])
if (config['transport'] != 'udp'):
raise Exception('Transport(%s) not implemented' %
str(config['transport']))
if (('templateRefreshTimeout' in config)
and (config['templateRefreshTimeout'] is not None)):
checkFloat('templateRefreshTimeout',
config['templateRefreshTimeout'], 1, 86400)
def create(cls, template, values):
checkType('template', (TemplateRecord, ), template)
checkType('values', (dict, ), values)
obj = cls()
obj.templateId = template.getId()
padIndex = None
recordLength = [0]
for i in xrange(len(template.fields)):
field = template.fields[i]
fName = field.name
value = None
if (fName == 'paddingOctets'):
if (values.has_key(fName)):
raise Exception(
'Do not provide value for field "paddingOctets". It is filled automatically, when present.'
)
value = None
padIndex = i
else:
if (not values.has_key(fName)):
raise Exception('No value provided for field(%s)' %
str(fName))
value = FieldValue.create(field, values[fName], recordLength)
obj.values.append(value)
if (padIndex is not None):
padLength = ((recordLength[0] + 1) % 4)
if (padLength > 0): padLength = 4 - padLength
obj.values[padIndex] = FieldValue.create(template.fields[i],
'\0' * padLength,
recordLength)
if ((recordLength[0] % 4) != 0):
raise Exception('Error computing padding')
return (obj)
def read(cls, session, rawData):
from Session import Session
checkType('session', (Session, ), session)
msg = cls()
msg.session = session
Message._readHeader(rawData, msg)
domain = msg.session.getDomain(msg.observationDomainId)
while (rawData.tell() < msg.length):
set_ = Set.read(domain, rawData)
if (set_.setId == 2):
msg.templateSets.append(set_)
msg.allSets.append(set_)
elif (set_.setId == 3):
msg.optionTemplateSets.append(set_)
msg.allSets.append(set_)
else:
msg.dataSets.append(set_)
msg.allSets.append(set_)
sequentiation = domain.getCollectorSequentiation()
_, _ = sequentiation.get()
numDataRecords = msg.getNumDataRecords()
sequentiation.update(numDataRecords, msg.exportTimeUTC)
return (msg)
def addRecord(self, record):
if (self.setType == 'template'):
checkType('record', (TemplateRecord, ), record)
elif (self.setType == 'optionTemplate'):
checkType('record', (OptionTemplateRecord, ), record)
elif (self.setType == 'data'):
checkType('record', (DataRecord, ), record)
else:
raise Exception('Invalid Set Type(%s)' % str(self.setType))
self.records.append(record)
def checkConfiguration(config):
checkType('config', (dict, ), config)
templatesDefinitionsFile = checkAttr('definitionsFile', config)
if (not os.path.isfile(templatesDefinitionsFile)):
raise Exception('templatesDefinitionsFile(%s) does not exist' %
templatesDefinitionsFile)
templatesDefinitions = json.loads(readFile(templatesDefinitionsFile))
for strTemplateId, templateAttr in templatesDefinitions.iteritems():
checkRegex('templateId', '[0-9]+', strTemplateId)
checkInteger('templateId', int(strTemplateId), 256, 65535)
checkType('templateAttr', (dict, ), templateAttr)
fields = checkAttr('fields', templateAttr)
checkType('fields', (list, ), fields)
for field in fields:
checkType('field', (dict, ), field)
name = checkAttr('name', field)
checkRegex('name', '[a-zA-Z0-9]+', name)
enterprise = checkAttr('enterprise', field)
checkRegex('enterprise', '[a-zA-Z0-9]+', enterprise)
pen = pen_alias.get(enterprise)
length = field.get('length')
checkInteger('length',
length,
minValue=1,
maxValue=VARIABLE_LENGTH,
allowNone=True)
if (pen is None):
raise Exception('Unknown Enterprise Alias(%s)' %
enterprise)
if (pen == -1):
FieldSpecifier.newIANA(name, length)
else:
FieldSpecifier.newEnterprise(name, pen, length)
def checkConfiguration(config):
checkType('config', (dict, ), config)
checkIPv4('listenIP', checkAttr('listenIP', config))
checkPort('listenPort', checkAttr('listenPort', config))
checkInteger('numWorkers', checkAttr('numWorkers', config), 1)
def _validate(self):
config = checkType('config', (dict, ), self.data)
LoggerConfigurator.checkConfiguration(checkAttr('logger', config))
Manager.checkConfiguration(checkAttr('manager', config))
def checkConfiguration(config):
checkType('config', (dict, ), config)
pass
def addDataRecord(self, values):
checkType('values', (dict, ), values)
self.records.append(DataRecord.create(self.template, values))
def createFromDict(cls, data):
checkType('data', (dict, ), data)
obj = cls()
obj.data = data
obj._validate()
return (obj)
def checkConfiguration(config):
#Comprobamos configuracion
checkType('config', (dict,), config)
checkIPv4('serverIP', checkAttr('serverIP', config))
checkPort('serverPort', checkAttr('serverPort', config))
