feat(policy): add Device domain model (1d77cb00) · Commits · TFS / controller

src/policy/src/main/java/eu/teraflow/policy/Serializer.java

+178 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@ import context.ContextOuterClass.ConfigRule_ACL;
		import context.ContextOuterClass.ConfigRule_Custom;
		import context.ContextOuterClass.ContextId;
		import context.ContextOuterClass.DeviceId;
		import context.ContextOuterClass.DeviceOperationalStatusEnum;
		import context.ContextOuterClass.Uuid;
		import eu.teraflow.policy.acl.AclAction;
		import eu.teraflow.policy.acl.AclEntry;
		@@ -51,6 +52,11 @@ import eu.teraflow.policy.context.model.ConstraintTypeSlaAvailability;
		import eu.teraflow.policy.context.model.ConstraintTypeSlaCapacity;
		import eu.teraflow.policy.context.model.ConstraintTypeSlaIsolationLevel;
		import eu.teraflow.policy.context.model.ConstraintTypeSlaLatency;
		import eu.teraflow.policy.context.model.Device;
		import eu.teraflow.policy.context.model.DeviceConfig;
		import eu.teraflow.policy.context.model.DeviceDriverEnum;
		import eu.teraflow.policy.context.model.DeviceOperationalStatus;
		import eu.teraflow.policy.context.model.EndPoint;
		import eu.teraflow.policy.context.model.EndPointId;
		import eu.teraflow.policy.context.model.Event;
		import eu.teraflow.policy.context.model.EventTypeEnum;
		@@ -1952,6 +1958,178 @@ public class Serializer {
		sliceId);
		}

		public ContextOuterClass.DeviceConfig serialize(DeviceConfig deviceConfig) {
		final var builder = ContextOuterClass.DeviceConfig.newBuilder();

		final var serializedConfigRules =
		deviceConfig.getConfigRules().stream().map(this::serialize).collect(Collectors.toList());
		builder.addAllConfigRules(serializedConfigRules);

		return builder.build();
		}

		public DeviceConfig deserialize(ContextOuterClass.DeviceConfig deviceConfig) {
		final var configRules =
		deviceConfig.getConfigRulesList().stream()
		.map(this::deserialize)
		.collect(Collectors.toList());

		return new DeviceConfig(configRules);
		}

		public ContextOuterClass.DeviceOperationalStatusEnum serialize(DeviceOperationalStatus opStatus) {
		switch (opStatus) {
		case ENABLED:
		return DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_ENABLED;
		case DISABLED:
		return DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_DISABLED;
		case UNDEFINED:
		default:
		return DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_UNDEFINED;
		}
		}

		public DeviceOperationalStatus deserialize(
		ContextOuterClass.DeviceOperationalStatusEnum opStatus) {
		switch (opStatus) {
		case DEVICEOPERATIONALSTATUS_ENABLED:
		return DeviceOperationalStatus.ENABLED;
		case DEVICEOPERATIONALSTATUS_DISABLED:
		return DeviceOperationalStatus.DISABLED;
		case DEVICEOPERATIONALSTATUS_UNDEFINED:
		case UNRECOGNIZED:
		default:
		return DeviceOperationalStatus.UNDEFINED;
		}
		}

		public ContextOuterClass.DeviceDriverEnum serialize(DeviceDriverEnum deviceDriverEnum) {
		switch (deviceDriverEnum) {
		case OPENCONFIG:
		return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_OPENCONFIG;
		case TRANSPORT_API:
		return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_TRANSPORT_API;
		case P4:
		return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_P4;
		case IETF_NETWORK_TOPOLOGY:
		return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_IETF_NETWORK_TOPOLOGY;
		case ONF_TR_352:
		return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_ONF_TR_352;
		case UNDEFINED:
		default:
		return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_UNDEFINED;
		}
		}

		public DeviceDriverEnum deserialize(
		ContextOuterClass.DeviceDriverEnum serializedDeviceDriverEnum) {
		switch (serializedDeviceDriverEnum) {
		case DEVICEDRIVER_OPENCONFIG:
		return DeviceDriverEnum.OPENCONFIG;
		case DEVICEDRIVER_TRANSPORT_API:
		return DeviceDriverEnum.TRANSPORT_API;
		case DEVICEDRIVER_P4:
		return DeviceDriverEnum.P4;
		case DEVICEDRIVER_IETF_NETWORK_TOPOLOGY:
		return DeviceDriverEnum.IETF_NETWORK_TOPOLOGY;
		case DEVICEDRIVER_ONF_TR_352:
		return DeviceDriverEnum.ONF_TR_352;
		case DEVICEDRIVER_UNDEFINED:
		case UNRECOGNIZED:
		default:
		return DeviceDriverEnum.UNDEFINED;
		}
		}

		public ContextOuterClass.EndPoint serialize(EndPoint endPoint) {
		final var builder = ContextOuterClass.EndPoint.newBuilder();

		final var endPointId = endPoint.getEndPointId();
		final var endPointType = endPoint.getEndPointType();
		final var kpiSampleTypes = endPoint.getKpiSampleTypes();
		final var endPointLocation = endPoint.getEndPointLocation();

		final var serializedEndPointId = serialize(endPointId);
		final var serializedKpiSampleTypes =
		kpiSampleTypes.stream().map(this::serialize).collect(Collectors.toList());
		final var serializedEndPointLocation = serialize(endPointLocation);

		builder.setEndpointId(serializedEndPointId);
		builder.setEndpointType(endPointType);
		builder.addAllKpiSampleTypes(serializedKpiSampleTypes);
		builder.setEndpointLocation(serializedEndPointLocation);

		return builder.build();
		}

		public EndPoint deserialize(ContextOuterClass.EndPoint serializedEndPoint) {
		final var serializedEndPointId = serializedEndPoint.getEndpointId();
		final var endPointType = serializedEndPoint.getEndpointType();
		final var serializedKpiSampleTypes = serializedEndPoint.getKpiSampleTypesList();
		final var serializedEndPointLocation = serializedEndPoint.getEndpointLocation();

		final var endPointId = deserialize(serializedEndPointId);
		final var kpiSampleTypes =
		serializedKpiSampleTypes.stream().map(this::deserialize).collect(Collectors.toList());
		final var endPointLocation = deserialize(serializedEndPointLocation);

		return new EndPoint(endPointId, endPointType, kpiSampleTypes, endPointLocation);
		}

		public ContextOuterClass.Device serialize(Device device) {
		final var builder = ContextOuterClass.Device.newBuilder();

		final var deviceIdUuid = serializeUuid(device.getDeviceId());
		final var deviceId = DeviceId.newBuilder().setDeviceUuid(deviceIdUuid);
		final var deviceType = device.getDeviceType();
		final var deviceConfig = device.getDeviceConfig();
		final var deviceOperationalStatus = device.getDeviceOperationalStatus();
		final var deviceDrivers = device.getDeviceDrivers();
		final var deviceEndPoints = device.getEndPoints();

		final var serializedDeviceConfig = serialize(deviceConfig);
		final var serializedDeviceOperationalStatus = serialize(deviceOperationalStatus);
		final var serializedDeviceDrivers =
		deviceDrivers.stream().map(this::serialize).collect(Collectors.toList());
		final var serializedDeviceEndPoints =
		deviceEndPoints.stream().map(this::serialize).collect(Collectors.toList());

		builder.setDeviceId(deviceId);
		builder.setDeviceType(deviceType);
		builder.setDeviceConfig(serializedDeviceConfig);
		builder.setDeviceOperationalStatus(serializedDeviceOperationalStatus);
		builder.addAllDeviceDrivers(serializedDeviceDrivers);
		builder.addAllDeviceEndpoints(serializedDeviceEndPoints);

		return builder.build();
		}

		public Device deserialize(ContextOuterClass.Device device) {

		final var serializedDeviceId = device.getDeviceId();
		final var deviceType = device.getDeviceType();
		final var serializedDeviceConfig = device.getDeviceConfig();
		final var serializedDeviceOperationalStatus = device.getDeviceOperationalStatus();
		final var serializedDeviceDrivers = device.getDeviceDriversList();
		final var serializedDeviceEndPoints = device.getDeviceEndpointsList();

		final var deviceId = deserialize(serializedDeviceId);
		final var deviceConfig = deserialize(serializedDeviceConfig);
		final var deviceOperationalStatus = deserialize(serializedDeviceOperationalStatus);
		final var deviceDrivers =
		serializedDeviceDrivers.stream().map(this::deserialize).collect(Collectors.toList());
		final var deviceEndPoints =
		serializedDeviceEndPoints.stream().map(this::deserialize).collect(Collectors.toList());

		return new Device(
		deviceId,
		deviceType,
		deviceConfig,
		deviceOperationalStatus,
		deviceDrivers,
		deviceEndPoints);
		}

		public Uuid serializeUuid(String uuid) {
		return Uuid.newBuilder().setUuid(uuid).build();
		}

src/policy/src/main/java/eu/teraflow/policy/context/model/Device.java

0 → 100644

+83 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
		*
		* 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.
		*/

		package eu.teraflow.policy.context.model;

		import eu.teraflow.policy.common.Util;
		import java.util.List;

		public class Device {

		private final String deviceId;
		private final String deviceType;
		private DeviceConfig deviceConfig;
		private DeviceOperationalStatus deviceOperationalStatus;
		private List<DeviceDriverEnum> deviceDrivers;
		private List<EndPoint> endPoints;

		public Device(
		String deviceId,
		String deviceType,
		DeviceConfig deviceConfig,
		DeviceOperationalStatus deviceOperationalStatus,
		List<DeviceDriverEnum> deviceDrivers,
		List<EndPoint> endPoints) {

		this.deviceId = deviceId;
		this.deviceType = deviceType;
		this.deviceConfig = deviceConfig;
		this.deviceOperationalStatus = deviceOperationalStatus;
		this.deviceDrivers = deviceDrivers;
		this.endPoints = endPoints;
		}

		public String getDeviceId() {
		return deviceId;
		}

		public String getDeviceType() {
		return deviceType;
		}

		public DeviceConfig getDeviceConfig() {
		return deviceConfig;
		}

		public DeviceOperationalStatus getDeviceOperationalStatus() {
		return deviceOperationalStatus;
		}

		public List<DeviceDriverEnum> getDeviceDrivers() {
		return deviceDrivers;
		}

		public List<EndPoint> getEndPoints() {
		return endPoints;
		}

		@Override
		public String toString() {
		return String.format(
		"%s:{deviceId:\"%s\", deviceType:\"%s\", %s, deviceOperationalStatus=\"%s\", [%s], [%s]}",
		getClass().getSimpleName(),
		deviceId,
		deviceType,
		deviceConfig,
		deviceOperationalStatus.toString(),
		Util.toString(deviceDrivers),
		Util.toString(endPoints));
		}
		}

src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceConfig.java

0 → 100644

+39 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
		*
		* 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.
		*/

		package eu.teraflow.policy.context.model;

		import eu.teraflow.policy.common.Util;
		import java.util.List;

		public class DeviceConfig {

		private final List<ConfigRule> configRules;

		public DeviceConfig(List<ConfigRule> configRules) {

		this.configRules = configRules;
		}

		public List<ConfigRule> getConfigRules() {
		return configRules;
		}

		@Override
		public String toString() {
		return String.format("%s:{[%s]}", getClass().getSimpleName(), Util.toString(configRules));
		}
		}

src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceDriverEnum.java

0 → 100644

+26 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
		*
		* 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.
		*/

		package eu.teraflow.policy.context.model;

		public enum DeviceDriverEnum {
		UNDEFINED,
		OPENCONFIG,
		TRANSPORT_API,
		P4,
		IETF_NETWORK_TOPOLOGY,
		ONF_TR_352
		}

src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceOperationalStatus.java

0 → 100644

+23 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
		*
		* 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.
		*/

		package eu.teraflow.policy.context.model;

		public enum DeviceOperationalStatus {
		UNDEFINED,
		DISABLED,
		ENABLED
		}