--- /dev/null
+/*-
+ * ========================LICENSE_START=================================
+ * O-RAN-SC
+ * %%
+ * Copyright (C) 2023 Nordix Foundation
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================LICENSE_END===================================
+ */
+
+package org.oran.pmproducer.filter;
+
+import java.lang.invoke.MethodHandles;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import org.oran.pmproducer.filter.PmReport.Event;
+import org.oran.pmproducer.filter.PmReport.MeasDataCollection;
+import org.oran.pmproducer.filter.PmReport.MeasInfoList;
+import org.oran.pmproducer.filter.PmReport.MeasResult;
+import org.oran.pmproducer.filter.PmReport.MeasTypes;
+import org.oran.pmproducer.filter.PmReport.MeasValuesList;
+import org.oran.pmproducer.filter.PmReport.Perf3gppFields;
+import org.oran.pmproducer.tasks.TopicListener.DataFromTopic;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.thymeleaf.util.StringUtils;
+
+public class PmReportFilter {
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+ private static com.google.gson.Gson gson = new com.google.gson.GsonBuilder() //
+ .disableHtmlEscaping() //
+ .excludeFieldsWithoutExposeAnnotation() //
+ .create();
+
+ // excludeFieldsWithoutExposeAnnotation is not needed when parsing and this is a
+ // bit quicker
+ private static com.google.gson.Gson gsonParse = new com.google.gson.GsonBuilder() //
+ .disableHtmlEscaping() //
+ .create();
+
+ @Getter
+ private final FilterData filterData;
+
+ @Getter
+ public static class FilterData {
+
+ public static class MeasTypeSpec {
+ static MeasTypeSpec empty = new MeasTypeSpec();
+
+ static MeasTypeSpec empty() {
+ return empty;
+ }
+
+ @Getter
+ String measuredObjClass;
+
+ @Getter
+ final Set<String> measTypes = new HashSet<>();
+
+ @Override
+ public boolean equals(Object obj) {
+ return measuredObjClass.equals(obj);
+ }
+
+ @Override
+ public int hashCode() {
+ return measuredObjClass.hashCode();
+ }
+ }
+
+ final Set<String> sourceNames = new HashSet<>();
+ final Set<String> measObjInstIds = new HashSet<>();
+ final Collection<MeasTypeSpec> measTypeSpecs = new ArrayList<>();
+ final Set<String> measuredEntityDns = new HashSet<>();
+
+ public void addMeasTypes(String measObjClass, String... measTypes) {
+ MeasTypeSpec spec = this.findMeasTypeSpec(measObjClass);
+ if (spec == null) {
+ spec = new MeasTypeSpec();
+ spec.measuredObjClass = measObjClass;
+ this.measTypeSpecs.add(spec);
+ }
+ for (String measType : measTypes) {
+ spec.measTypes.add(measType);
+ }
+ }
+
+ public void addMeasTypes(String measObjClass, Collection<String> measTypes) {
+ for (String measType : measTypes) {
+ addMeasTypes(measObjClass, measType);
+ }
+ }
+
+ @Setter
+ String pmRopStartTime;
+
+ @Setter
+ String pmRopEndTime;
+
+ public void addAll(FilterData other) {
+ addAll(other.sourceNames, sourceNames);
+ addAll(other.measObjInstIds, measObjInstIds);
+ addAll(other.measTypeSpecs);
+ addAll(other.measuredEntityDns, measuredEntityDns);
+ }
+
+ public MeasTypeSpec getMeasTypeSpec(String measuredObjClass) {
+ if (measTypeSpecs.isEmpty()) {
+ return MeasTypeSpec.empty();
+ }
+ return findMeasTypeSpec(measuredObjClass);
+ }
+
+ private MeasTypeSpec findMeasTypeSpec(String measuredObjClass) {
+ for (MeasTypeSpec t : this.measTypeSpecs) {
+ if (t.measuredObjClass.equals(measuredObjClass)) {
+ return t;
+ }
+ }
+ return null;
+ }
+
+ private void addAll(Collection<MeasTypeSpec> measTypes) {
+ for (MeasTypeSpec s : measTypes) {
+ addMeasTypes(s.getMeasuredObjClass(), s.getMeasTypes());
+ }
+ }
+
+ private void addAll(Set<String> source, Set<String> dst) {
+ if (source.isEmpty()) {
+ dst.clear();
+ } else if (dst.isEmpty()) {
+ // Nothing, this means 'match all'
+ } else {
+ dst.addAll(source);
+ }
+ }
+ }
+
+ public static PmReport parse(String string) {
+ return gsonParse.fromJson(string, PmReport.class);
+ }
+
+ private static class MeasTypesIndexed extends PmReport.MeasTypes {
+
+ private Map<String, Integer> map = new HashMap<>();
+
+ public int addP(String measTypeName) {
+ Integer p = map.get(measTypeName);
+ if (p != null) {
+ return p;
+ } else {
+ sMeasTypesList.add(measTypeName);
+ this.map.put(measTypeName, sMeasTypesList.size());
+ return sMeasTypesList.size();
+ }
+ }
+ }
+
+ public PmReportFilter(FilterData filterData) {
+ this.filterData = filterData;
+ }
+
+ public FilteredData filter(DataFromTopic data) {
+ try {
+ PmReport report = getPmReport(data);
+
+ if (report.event == null || report.event.getPerf3gppFields() == null) {
+ logger.warn("Received PM report with no perf3gppFields, ignored. {}", data);
+ return FilteredData.empty();
+ }
+
+ PmReport reportFiltered = filter(report, this.filterData);
+ if (reportFiltered == null) {
+ return FilteredData.empty();
+ }
+ return new FilteredData(data.infoTypeId, data.key, gson.toJson(reportFiltered).getBytes());
+ } catch (Exception e) {
+ logger.warn("Could not parse PM data. {}, reason: {}", data, e.getMessage());
+ return FilteredData.empty();
+ }
+ }
+
+ @SuppressWarnings("java:S2445") // "data" is a method parameter, and should not be used for synchronization.
+ private PmReport getPmReport(DataFromTopic data) {
+ synchronized (data) {
+ if (data.getCachedPmReport() == null) {
+ data.setCachedPmReport(parse((data.valueAsString())));
+ }
+ return data.getCachedPmReport();
+ }
+ }
+
+ /**
+ * Updates the report based on the filter data.
+ *
+ * @param report
+ * @param filterData
+ * @return true if there is anything left in the report
+ */
+ private PmReport filter(PmReport report, FilterData filterData) {
+ if (!matchSourceNames(report, filterData.sourceNames)) {
+ return null;
+ }
+
+ Collection<MeasInfoList> filteredMeasObjs = createMeasObjInstIds(report, filterData);
+ if (filteredMeasObjs.isEmpty()) {
+ return null;
+ }
+ MeasDataCollection measDataCollection = report.event.getPerf3gppFields().getMeasDataCollection().toBuilder() //
+ .measInfoList(filteredMeasObjs) //
+ .build();
+
+ Perf3gppFields perf3gppFields =
+ report.event.getPerf3gppFields().toBuilder().measDataCollection(measDataCollection) //
+ .build();
+ Event event = report.event.toBuilder() //
+ .perf3gppFields(perf3gppFields) //
+ .build();
+
+ return report.toBuilder() //
+ .event(event) //
+ .build();
+ }
+
+ private boolean isContainedInAny(String aString, Collection<String> collection) {
+ for (String s : collection) {
+ if (StringUtils.contains(aString, s) == Boolean.TRUE) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean isMeasResultMatch(MeasResult measResult, MeasTypes measTypes,
+ FilterData.MeasTypeSpec measTypesSpec) {
+ String measType = measTypes.getMeasType(measResult.getP());
+ return measTypesSpec.measTypes.isEmpty() || measTypesSpec.measTypes.contains(measType);
+ }
+
+ private Collection<MeasResult> createMeasResults(Collection<MeasResult> oldMeasResults, MeasTypes measTypes,
+ FilterData.MeasTypeSpec measTypesSpec) {
+ Collection<MeasResult> newMeasResults = new ArrayList<>();
+
+ for (MeasResult measResult : oldMeasResults) {
+ if (isMeasResultMatch(measResult, measTypes, measTypesSpec)) {
+ newMeasResults.add(measResult.toBuilder().build());
+ }
+ }
+ return newMeasResults;
+ }
+
+ private boolean isMeasInstIdMatch(String measObjInstId, FilterData filter) {
+ return filter.measObjInstIds.isEmpty() || isContainedInAny(measObjInstId, filter.measObjInstIds);
+ }
+
+ private String managedObjectClass(String distinguishedName) {
+ int lastRdn = distinguishedName.lastIndexOf(",");
+ if (lastRdn == -1) {
+ return "";
+ }
+ int lastEqualChar = distinguishedName.indexOf("=", lastRdn);
+ if (lastEqualChar == -1) {
+ return "";
+ }
+ return distinguishedName.substring(lastRdn + 1, lastEqualChar);
+ }
+
+ private FilterData.MeasTypeSpec getMeasTypeSpec(String measObjInstId, FilterData filter) {
+ String measObjClass = managedObjectClass(measObjInstId);
+ return filter.getMeasTypeSpec(measObjClass);
+ }
+
+ private MeasValuesList createMeasValuesList(MeasValuesList oldMeasValues, MeasTypes measTypes, FilterData filter) {
+ FilterData.MeasTypeSpec measTypesSpec = getMeasTypeSpec(oldMeasValues.getMeasObjInstId(), filter);
+ if (measTypesSpec == null) {
+ return MeasValuesList.empty();
+ }
+
+ if (!isMeasInstIdMatch(oldMeasValues.getMeasObjInstId(), filter)) {
+ return MeasValuesList.empty();
+ }
+
+ Collection<MeasResult> newResults = createMeasResults(oldMeasValues.getMeasResults(), measTypes, measTypesSpec);
+ return oldMeasValues.toBuilder() //
+ .measResults(newResults) //
+ .build();
+ }
+
+ private MeasTypes createMeasTypes(Collection<MeasValuesList> newMeasValues, MeasTypes oldMMeasTypes) {
+ MeasTypesIndexed newMeasTypes = new MeasTypesIndexed();
+ for (MeasValuesList l : newMeasValues) {
+ for (MeasResult r : l.getMeasResults()) {
+ String measTypeName = oldMMeasTypes.getMeasType(r.getP());
+ int newP = newMeasTypes.addP(measTypeName);
+ r.setP(newP);
+ }
+ }
+ return newMeasTypes;
+ }
+
+ private MeasInfoList createMeasInfoList(MeasInfoList oldMeasInfoList, FilterData filter) {
+
+ Collection<MeasValuesList> measValueLists = new ArrayList<>();
+ for (MeasValuesList oldValues : oldMeasInfoList.getMeasValuesList()) {
+ MeasValuesList newMeasValues = createMeasValuesList(oldValues, oldMeasInfoList.getMeasTypes(), filter);
+ if (!newMeasValues.isEmpty()) {
+ measValueLists.add(newMeasValues);
+ }
+ }
+
+ MeasTypes newMeasTypes = createMeasTypes(measValueLists, oldMeasInfoList.getMeasTypes());
+
+ return oldMeasInfoList.toBuilder() //
+ .measTypes(newMeasTypes).measValuesList(measValueLists) //
+ .build();
+
+ }
+
+ private boolean matchMeasuredEntityDns(PmReport report, FilterData filter) {
+ return filter.measuredEntityDns.isEmpty()
+ || this.isContainedInAny(report.event.getPerf3gppFields().getMeasDataCollection().getMeasuredEntityDn(),
+ filter.measuredEntityDns);
+ }
+
+ private Collection<MeasInfoList> createMeasObjInstIds(PmReport report, FilterData filter) {
+ Collection<MeasInfoList> newList = new ArrayList<>();
+ if (!matchMeasuredEntityDns(report, filter)) {
+ return newList;
+ }
+ for (MeasInfoList oldMeasInfoList : report.event.getPerf3gppFields().getMeasDataCollection()
+ .getMeasInfoList()) {
+ MeasInfoList l = createMeasInfoList(oldMeasInfoList, filter);
+ if (!l.getMeasValuesList().isEmpty()) {
+ newList.add(l);
+ }
+ }
+ return newList;
+ }
+
+ private boolean matchSourceNames(PmReport report, Collection<String> sourceNames) {
+ return sourceNames.isEmpty() || sourceNames.contains(report.event.getCommonEventHeader().getSourceName());
+ }
+
+}
Code Review / nonrtric / plt / ranpm.git / blobdiff