Commit b0c149a0 authored by Fotis Soldatos's avatar Fotis Soldatos
Browse files

Merge branch 'automation/add-acl-proto-to-path' into 'develop' 

feat(automation): add acl.proto in path and update domain models

See merge request teraflow-h2020/controller!132
parents 2d6184e5 884c9145

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

}