Merge branch 'automation/add-acl-proto-to-path' into 'develop' (b0c149a0) · Commits · TFS / controller

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

+425 −9

Original line number	Diff line number	Diff line
		@@ -16,19 +16,36 @@

		package eu.teraflow.automation;

		import acl.Acl;
		import automation.Automation;
		import context.ContextOuterClass;
		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.automation.acl.AclAction;
		import eu.teraflow.automation.acl.AclEntry;
		import eu.teraflow.automation.acl.AclForwardActionEnum;
		import eu.teraflow.automation.acl.AclLogActionEnum;
		import eu.teraflow.automation.acl.AclMatch;
		import eu.teraflow.automation.acl.AclRuleSet;
		import eu.teraflow.automation.acl.AclRuleTypeEnum;
		import eu.teraflow.automation.context.model.Event;
		import eu.teraflow.automation.context.model.EventTypeEnum;
		import eu.teraflow.automation.device.model.ConfigActionEnum;
		import eu.teraflow.automation.device.model.ConfigRule;
		import eu.teraflow.automation.device.model.ConfigRuleAcl;
		import eu.teraflow.automation.device.model.ConfigRuleCustom;
		import eu.teraflow.automation.device.model.ConfigRuleTypeAcl;
		import eu.teraflow.automation.device.model.ConfigRuleTypeCustom;
		import eu.teraflow.automation.device.model.Device;
		import eu.teraflow.automation.device.model.DeviceConfig;
		import eu.teraflow.automation.device.model.DeviceEvent;
		import eu.teraflow.automation.device.model.DeviceOperationalStatus;
		import eu.teraflow.automation.device.model.EndPointId;
		import eu.teraflow.automation.device.model.TopologyId;
		import eu.teraflow.automation.model.DeviceRole;
		import eu.teraflow.automation.model.DeviceRoleId;
		import eu.teraflow.automation.model.DeviceRoleType;
		@@ -153,18 +170,32 @@ public class Serializer {
		}
		}

		public ContextOuterClass.Timestamp serialize(double timestamp) {
		final var builder = ContextOuterClass.Timestamp.newBuilder();

		builder.setTimestamp(timestamp);

		return builder.build();
		}

		public double deserialize(ContextOuterClass.Timestamp serializedTimeStamp) {

		return serializedTimeStamp.getTimestamp();
		}

		public ContextOuterClass.Event serialize(Event event) {
		final var builder = ContextOuterClass.Event.newBuilder();

		final var eventType = serialize(event.getEventTypeEnum());
		final var timestamp = serialize(event.getTimestamp());
		builder.setEventType(eventType);
		builder.setTimestamp(event.getTimestamp());
		builder.setTimestamp(timestamp);

		return builder.build();
		}

		public Event deserialize(ContextOuterClass.Event serializedEvent) {
		final var timestamp = serializedEvent.getTimestamp();
		final var timestamp = deserialize(serializedEvent.getTimestamp());
		final var eventType = deserialize(serializedEvent.getEventType());

		return new Event(timestamp, eventType);
		@@ -213,21 +244,406 @@ public class Serializer {
		}
		}

		public ContextId serializeContextId(String expectedContextId) {
		final var builder = ContextId.newBuilder();
		final var uuid = serializeUuid(expectedContextId);

		builder.setContextUuid(uuid);

		return builder.build();
		}

		public String deserialize(ContextId contextId) {
		return contextId.getContextUuid().getUuid();
		}

		public ContextOuterClass.TopologyId serialize(TopologyId topologyId) {
		final var builder = ContextOuterClass.TopologyId.newBuilder();

		final var topologyIdContextId = topologyId.getContextId();
		final var topologyIdId = topologyId.getId();

		final var contextId = serializeContextId(topologyIdContextId);
		final var topologyIdIdUuid = serializeUuid(topologyIdId);

		builder.setContextId(contextId);
		builder.setTopologyUuid(topologyIdIdUuid);

		return builder.build();
		}

		public TopologyId deserialize(ContextOuterClass.TopologyId topologyId) {
		final var topologyIdContextId = deserialize(topologyId.getContextId());
		final var topologyIdId = deserialize(topologyId.getTopologyUuid());

		return new TopologyId(topologyIdContextId, topologyIdId);
		}

		public ContextOuterClass.EndPointId serialize(EndPointId endPointId) {
		final var builder = ContextOuterClass.EndPointId.newBuilder();

		final var endPointIdTopologyId = endPointId.getTopologyId();
		final var endPointIdDeviceId = endPointId.getDeviceId();
		final var endPointIdId = endPointId.getId();

		final var serializedTopologyId = serialize(endPointIdTopologyId);
		final var serializedDeviceId = serializeDeviceId(endPointIdDeviceId);
		final var serializedEndPointIdId = serializeUuid(endPointIdId);

		builder.setTopologyId(serializedTopologyId);
		builder.setDeviceId(serializedDeviceId);
		builder.setEndpointUuid(serializedEndPointIdId);

		return builder.build();
		}

		public EndPointId deserialize(ContextOuterClass.EndPointId serializedEndPointId) {
		final var serializedTopologyId = serializedEndPointId.getTopologyId();
		final var serializedDeviceId = serializedEndPointId.getDeviceId();
		final var serializedId = serializedEndPointId.getEndpointUuid();

		final var topologyId = deserialize(serializedTopologyId);
		final var deviceId = deserialize(serializedDeviceId);
		final var id = deserialize(serializedId);

		return new EndPointId(topologyId, deviceId, id);
		}

		public Acl.AclRuleTypeEnum serialize(AclRuleTypeEnum aclRuleTypeEnum) {
		switch (aclRuleTypeEnum) {
		case IPV4:
		return Acl.AclRuleTypeEnum.ACLRULETYPE_IPV4;
		case IPV6:
		return Acl.AclRuleTypeEnum.ACLRULETYPE_IPV6;
		case L2:
		return Acl.AclRuleTypeEnum.ACLRULETYPE_L2;
		case MPLS:
		return Acl.AclRuleTypeEnum.ACLRULETYPE_MPLS;
		case MIXED:
		return Acl.AclRuleTypeEnum.ACLRULETYPE_MIXED;
		case UNDEFINED:
		return Acl.AclRuleTypeEnum.ACLRULETYPE_UNDEFINED;
		default:
		return Acl.AclRuleTypeEnum.UNRECOGNIZED;
		}
		}

		public AclRuleTypeEnum deserialize(Acl.AclRuleTypeEnum serializedAclRuleTypeEnum) {
		switch (serializedAclRuleTypeEnum) {
		case ACLRULETYPE_IPV4:
		return AclRuleTypeEnum.IPV4;
		case ACLRULETYPE_IPV6:
		return AclRuleTypeEnum.IPV6;
		case ACLRULETYPE_L2:
		return AclRuleTypeEnum.L2;
		case ACLRULETYPE_MPLS:
		return AclRuleTypeEnum.MPLS;
		case ACLRULETYPE_MIXED:
		return AclRuleTypeEnum.MIXED;
		case UNRECOGNIZED:
		default:
		return AclRuleTypeEnum.UNDEFINED;
		}
		}

		public Acl.AclMatch serialize(AclMatch aclMatch) {
		final var builder = Acl.AclMatch.newBuilder();

		final var dscp = aclMatch.getDscp();
		final var protocol = aclMatch.getProtocol();
		final var srcAddress = aclMatch.getSrcAddress();
		final var dstAddress = aclMatch.getDstAddress();
		final var srcPort = aclMatch.getSrcPort();
		final var dstPort = aclMatch.getDstPort();
		final var startMplsLabel = aclMatch.getStartMplsLabel();
		final var endMplsLabel = aclMatch.getEndMplsLabel();

		builder.setDscp(dscp);
		builder.setProtocol(protocol);
		builder.setSrcAddress(srcAddress);
		builder.setDstAddress(dstAddress);
		builder.setSrcPort(srcPort);
		builder.setDstPort(dstPort);
		builder.setStartMplsLabel(startMplsLabel);
		builder.setEndMplsLabel(endMplsLabel);

		return builder.build();
		}

		public AclMatch deserialize(Acl.AclMatch serializedAclMatch) {
		final var dscp = serializedAclMatch.getDscp();
		final var protocol = serializedAclMatch.getProtocol();
		final var srcAddress = serializedAclMatch.getSrcAddress();
		final var dstAddress = serializedAclMatch.getDstAddress();
		final var srcPort = serializedAclMatch.getSrcPort();
		final var dstPort = serializedAclMatch.getDstPort();
		final var startMplsLabel = serializedAclMatch.getStartMplsLabel();
		final var endMplsLabel = serializedAclMatch.getEndMplsLabel();

		return new AclMatch(
		dscp, protocol, srcAddress, dstAddress, srcPort, dstPort, startMplsLabel, endMplsLabel);
		}

		public Acl.AclForwardActionEnum serialize(AclForwardActionEnum aclForwardActionEnum) {
		switch (aclForwardActionEnum) {
		case DROP:
		return Acl.AclForwardActionEnum.ACLFORWARDINGACTION_DROP;
		case ACCEPT:
		return Acl.AclForwardActionEnum.ACLFORWARDINGACTION_ACCEPT;
		case REJECT:
		return Acl.AclForwardActionEnum.ACLFORWARDINGACTION_REJECT;
		case UNDEFINED:
		return Acl.AclForwardActionEnum.ACLFORWARDINGACTION_UNDEFINED;
		default:
		return Acl.AclForwardActionEnum.UNRECOGNIZED;
		}
		}

		public AclForwardActionEnum deserialize(Acl.AclForwardActionEnum serializedAclForwardActionEnum) {
		switch (serializedAclForwardActionEnum) {
		case ACLFORWARDINGACTION_DROP:
		return AclForwardActionEnum.DROP;
		case ACLFORWARDINGACTION_ACCEPT:
		return AclForwardActionEnum.ACCEPT;
		case ACLFORWARDINGACTION_REJECT:
		return AclForwardActionEnum.REJECT;
		case UNRECOGNIZED:
		default:
		return AclForwardActionEnum.UNDEFINED;
		}
		}

		public Acl.AclLogActionEnum serialize(AclLogActionEnum aclLogActionEnum) {
		switch (aclLogActionEnum) {
		case NO_LOG:
		return Acl.AclLogActionEnum.ACLLOGACTION_NOLOG;
		case SYSLOG:
		return Acl.AclLogActionEnum.ACLLOGACTION_SYSLOG;
		case UNDEFINED:
		return Acl.AclLogActionEnum.ACLLOGACTION_UNDEFINED;
		default:
		return Acl.AclLogActionEnum.UNRECOGNIZED;
		}
		}

		public AclLogActionEnum deserialize(Acl.AclLogActionEnum serializedAclLogActionEnum) {
		switch (serializedAclLogActionEnum) {
		case ACLLOGACTION_NOLOG:
		return AclLogActionEnum.NO_LOG;
		case ACLLOGACTION_SYSLOG:
		return AclLogActionEnum.SYSLOG;
		case UNRECOGNIZED:
		default:
		return AclLogActionEnum.UNDEFINED;
		}
		}

		public Acl.AclAction serialize(AclAction aclAction) {
		final var builder = Acl.AclAction.newBuilder();

		final var aclForwardActionEnum = aclAction.getAclForwardActionEnum();
		final var aclLogActionEnum = aclAction.getAclLogActionEnum();

		final var serializedAclForwardActionEnum = serialize(aclForwardActionEnum);
		final var serializedAclLogActionEnum = serialize(aclLogActionEnum);

		builder.setForwardAction(serializedAclForwardActionEnum);
		builder.setLogAction(serializedAclLogActionEnum);

		return builder.build();
		}

		public AclAction deserialize(Acl.AclAction serializedAclAction) {
		final var serializedAclForwardActionEnum = serializedAclAction.getForwardAction();
		final var serializedAclLogActionEnum = serializedAclAction.getLogAction();

		final var aclForwardActionEnum = deserialize(serializedAclForwardActionEnum);
		final var aclLogActionEnum = deserialize(serializedAclLogActionEnum);

		return new AclAction(aclForwardActionEnum, aclLogActionEnum);
		}

		public Acl.AclEntry serialize(AclEntry aclEntry) {
		final var builder = Acl.AclEntry.newBuilder();

		final var sequenceId = aclEntry.getSequenceId();
		final var description = aclEntry.getDescription();
		final var aclMatch = aclEntry.getMatch();
		final var aclAction = aclEntry.getAction();

		final var serializedAclMatch = serialize(aclMatch);
		final var serializedAclAction = serialize(aclAction);

		builder.setSequenceId(sequenceId);
		builder.setDescription(description);
		builder.setMatch(serializedAclMatch);
		builder.setAction(serializedAclAction);

		return builder.build();
		}

		public AclEntry deserialize(Acl.AclEntry serializedAclEntry) {
		final var sequenceId = serializedAclEntry.getSequenceId();
		final var description = serializedAclEntry.getDescription();
		final var serializedAclMatch = serializedAclEntry.getMatch();
		final var serializedAclAction = serializedAclEntry.getAction();

		final var aclMatch = deserialize(serializedAclMatch);
		final var aclAction = deserialize(serializedAclAction);

		return new AclEntry(sequenceId, description, aclMatch, aclAction);
		}

		public Acl.AclRuleSet serialize(AclRuleSet aclRuleSet) {
		final var builder = Acl.AclRuleSet.newBuilder();

		final var name = aclRuleSet.getName();
		final var type = aclRuleSet.getType();
		final var description = aclRuleSet.getDescription();
		final var userId = aclRuleSet.getUserId();
		final var entries = aclRuleSet.getEntries();

		final var serializedType = serialize(type);
		final var serializedEntries =
		entries.stream().map(this::serialize).collect(Collectors.toList());

		builder.setName(name);
		builder.setType(serializedType);
		builder.setDescription(description);
		builder.setUserId(userId);
		builder.addAllEntries(serializedEntries);

		return builder.build();
		}

		public AclRuleSet deserialize(Acl.AclRuleSet serializedAclRuleSet) {
		final var serializedName = serializedAclRuleSet.getName();
		final var serializedType = serializedAclRuleSet.getType();
		final var serializedDescription = serializedAclRuleSet.getDescription();
		final var serializedUserId = serializedAclRuleSet.getUserId();
		final var serializedEntries = serializedAclRuleSet.getEntriesList();

		final var type = deserialize(serializedType);
		final var entries =
		serializedEntries.stream().map(this::deserialize).collect(Collectors.toList());

		return new AclRuleSet(serializedName, type, serializedDescription, serializedUserId, entries);
		}

		public ConfigRule_ACL serialize(ConfigRuleAcl configRuleAcl) {
		final var builder = ContextOuterClass.ConfigRule_ACL.newBuilder();

		final var endPointId = configRuleAcl.getEndPointId();
		final var aclRuleSet = configRuleAcl.getRuleSet();

		final var serializedEndPointId = serialize(endPointId);
		final var serializedAclRuleSet = serialize(aclRuleSet);

		builder.setEndpointId(serializedEndPointId);
		builder.setRuleSet(serializedAclRuleSet);

		return builder.build();
		}

		public ConfigRuleAcl deserialize(ConfigRule_ACL serializedConfigRuleAcl) {
		final var serializedEndPointId = serializedConfigRuleAcl.getEndpointId();
		final var serializedAclRuleSet = serializedConfigRuleAcl.getRuleSet();

		final var endPointId = deserialize(serializedEndPointId);
		final var aclRuleSet = deserialize(serializedAclRuleSet);

		return new ConfigRuleAcl(endPointId, aclRuleSet);
		}

		public ConfigRule_Custom serialize(ConfigRuleCustom configRuleCustom) {
		final var builder = ConfigRule_Custom.newBuilder();

		final var resourceKey = configRuleCustom.getResourceKey();
		final var resourceValue = configRuleCustom.getResourceValue();

		builder.setResourceKey(resourceKey);
		builder.setResourceValue(resourceValue);

		return builder.build();
		}

		public ConfigRuleCustom deserialize(ConfigRule_Custom serializedConfigRuleCustom) {
		final var serializedResourceKey = serializedConfigRuleCustom.getResourceKey();
		final var serializedResourceValue = serializedConfigRuleCustom.getResourceValue();

		return new ConfigRuleCustom(serializedResourceKey, serializedResourceValue);
		}

		public ContextOuterClass.ConfigRule serialize(ConfigRule configRule) {
		final var builder = ContextOuterClass.ConfigRule.newBuilder();

		builder.setAction(serialize(configRule.getConfigActionEnum()));
		builder.setResourceKey(configRule.getResourceKey());
		builder.setResourceValue(configRule.getResourceValue());
		final var configActionEnum = configRule.getConfigActionEnum();
		final var configRuleType = configRule.getConfigRuleType();
		final var configRuleTypeSpecificType = configRuleType.getConfigRuleType();

		if (configRuleTypeSpecificType instanceof ConfigRuleAcl) {
		final var endPointId = ((ConfigRuleAcl) configRuleTypeSpecificType).getEndPointId();
		final var aclRuleSet = ((ConfigRuleAcl) configRuleTypeSpecificType).getRuleSet();

		final var serializedEndPointId = serialize(endPointId);
		final var serializedAclRuleSet = serialize(aclRuleSet);

		final var serializedConfigRuleAcl =
		ConfigRule_ACL.newBuilder()
		.setEndpointId(serializedEndPointId)
		.setRuleSet(serializedAclRuleSet)
		.build();

		builder.setAcl(serializedConfigRuleAcl);
		}

		if (configRuleTypeSpecificType instanceof ConfigRuleCustom) {
		final var configRuleCustomResourceKey =
		((ConfigRuleCustom) configRuleTypeSpecificType).getResourceKey();
		final var configRuleCustomResourceValue =
		((ConfigRuleCustom) configRuleTypeSpecificType).getResourceValue();

		final var serializedConfigRuleCustom =
		ConfigRule_Custom.newBuilder()
		.setResourceKey(configRuleCustomResourceKey)
		.setResourceValue(configRuleCustomResourceValue)
		.build();

		builder.setCustom(serializedConfigRuleCustom);
		}

		final var serializedConfigActionEnum = serialize(configActionEnum);

		builder.setAction(serializedConfigActionEnum);

		return builder.build();
		}

		public ConfigRule deserialize(ContextOuterClass.ConfigRule configRule) {
		final var configActionEnum = deserialize(configRule.getAction());
		public ConfigRule deserialize(ContextOuterClass.ConfigRule serializedConfigRule) {
		final var serializedConfigActionEnum = serializedConfigRule.getAction();
		final var typeOfConfigRule = serializedConfigRule.getConfigRuleCase();

		final var configActionEnum = deserialize(serializedConfigActionEnum);

		switch (typeOfConfigRule) {
		case ACL:
		final var serializedConfigRuleAcl = serializedConfigRule.getAcl();

		final var configRuleAcl = deserialize(serializedConfigRuleAcl);
		final var configRuleTypeAcl = new ConfigRuleTypeAcl(configRuleAcl);

		return new ConfigRule(
		configActionEnum, configRule.getResourceKey(), configRule.getResourceValue());
		return new ConfigRule(configActionEnum, configRuleTypeAcl);
		case CUSTOM:
		final var serializedConfigRuleCustom = serializedConfigRule.getCustom();

		final var configRuleCustom = deserialize(serializedConfigRuleCustom);
		final var configRuleTypeCustom = new ConfigRuleTypeCustom(configRuleCustom);

		return new ConfigRule(configActionEnum, configRuleTypeCustom);
		default:
		case CONFIGRULE_NOT_SET:
		throw new IllegalStateException("Config Rule not set");
		}
		}

		public ContextOuterClass.DeviceConfig serialize(DeviceConfig deviceConfig) {

src/automation/src/main/java/eu/teraflow/automation/acl/AclAction.java

0 → 100644

+43 −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.automation.acl;

		public class AclAction {

		private final AclForwardActionEnum aclForwardActionEnum;
		private final AclLogActionEnum aclLogActionEnum;

		public AclAction(AclForwardActionEnum aclForwardActionEnum, AclLogActionEnum aclLogActionEnum) {
		this.aclForwardActionEnum = aclForwardActionEnum;
		this.aclLogActionEnum = aclLogActionEnum;
		}

		public AclForwardActionEnum getAclForwardActionEnum() {
		return aclForwardActionEnum;
		}

		public AclLogActionEnum getAclLogActionEnum() {
		return aclLogActionEnum;
		}

		@Override
		public String toString() {
		return String.format(
		"%s:{aclForwardActionEnum:\"%s\", aclLogActionEnum:\"%s\"}",
		getClass().getSimpleName(), aclForwardActionEnum.toString(), aclLogActionEnum.toString());
		}
		}

src/automation/src/main/java/eu/teraflow/automation/acl/AclEntry.java

0 → 100644

+55 −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.automation.acl;

		public class AclEntry {

		private final int sequenceId;
		private final String description;
		private final AclMatch match;
		private final AclAction action;

		public AclEntry(int sequenceId, String description, AclMatch match, AclAction action) {
		this.sequenceId = sequenceId;
		this.description = description;
		this.match = match;
		this.action = action;
		}

		public int getSequenceId() {
		return sequenceId;
		}

		public String getDescription() {
		return description;
		}

		public AclMatch getMatch() {
		return match;
		}

		public AclAction getAction() {
		return action;
		}

		@Override
		public String toString() {
		return String.format(
		"%s:{sequenceId:\"%d\", description:\"%s\", %s, %s}",
		getClass().getSimpleName(), sequenceId, description, match, action);
		}
		}

src/automation/src/main/java/eu/teraflow/automation/acl/AclForwardActionEnum.java

0 → 100644

+24 −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.automation.acl;

		public enum AclForwardActionEnum {
		UNDEFINED,
		DROP,
		ACCEPT,
		REJECT,
		}

src/automation/src/main/java/eu/teraflow/automation/acl/AclLogActionEnum.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.automation.acl;

		public enum AclLogActionEnum {
		UNDEFINED,
		NO_LOG,
		SYSLOG
		}