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))