Java RuleId类代码示例

import org.onosproject.acl.RuleId; //导入依赖的package包/类
/**
 * Generate new ACL flow rules for new host following the given ACL rule.
 */
private void processHostAddedEvent(HostEvent event, AclRule rule) {
    DeviceId deviceId = event.subject().location().deviceId();
    for (IpAddress address : event.subject().ipAddresses()) {
        if ((rule.srcIp() != null) ?
                (checkIpInCidr(address.getIp4Address(), rule.srcIp())) :
                (checkIpInCidr(address.getIp4Address(), rule.dstIp()))) {
            if (!aclStore.checkIfRuleWorksInDevice(rule.id(), deviceId)) {
                List<RuleId> allowingRuleList = aclStore
                        .getAllowingRuleByDenyingRule(rule.id());
                if (allowingRuleList != null) {
                    for (RuleId allowingRuleId : allowingRuleList) {
                        generateAclFlow(aclStore.getAclRule(allowingRuleId), deviceId);
                    }
                }
                generateAclFlow(rule, deviceId);
            }
        }
    }
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
/**
 * Enforces denying ACL rule by ACL flow rules.
 */
private void enforceRuleAdding(AclRule rule) {
    Set<DeviceId> dpidSet;
    if (rule.srcIp() != null) {
        dpidSet = getDeviceIdSet(rule.srcIp());
    } else {
        dpidSet = getDeviceIdSet(rule.dstIp());
    }

    for (DeviceId deviceId : dpidSet) {
        List<RuleId> allowingRuleList = aclStore.getAllowingRuleByDenyingRule(rule.id());
        if (allowingRuleList != null) {
            for (RuleId allowingRuleId : allowingRuleList) {
                generateAclFlow(aclStore.getAclRule(allowingRuleId), deviceId);
            }
        }
        generateAclFlow(rule, deviceId);
    }
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public AclRule getAclRule(RuleId ruleId) {
    Versioned<AclRule> rule = ruleSet.get(ruleId);
    if (rule != null) {
        return rule.value();
    } else {
        return null;
    }
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public Set<FlowRule> getFlowByRule(RuleId ruleId) {
    Versioned<Set<FlowRule>> flowRuleSet = ruleToFlow.get(ruleId);
    if (flowRuleSet != null) {
        return flowRuleSet.value();
    } else {
        return null;
    }
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public void addRuleToFlowMapping(RuleId ruleId, FlowRule flowRule) {
    ruleToFlow.computeIf(ruleId,
                         flowRuleSet -> (flowRuleSet == null || !flowRuleSet.contains(flowRule)),
                         (id, flowRuleSet) -> {
                             Set<FlowRule> newSet = new HashSet<>();
                             if (flowRuleSet != null) {
                                 newSet.addAll(flowRuleSet);
                             }
                             newSet.add(flowRule);
                             return newSet;
                         });
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public List<RuleId> getAllowingRuleByDenyingRule(RuleId denyingRuleId) {
    Versioned<List<RuleId>> allowRuleIdSet = denyRuleToAllowRule.get(denyingRuleId);
    if (allowRuleIdSet != null) {
        return allowRuleIdSet.value();
    } else {
        return null;
    }
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public void addDenyToAllowMapping(RuleId denyingRuleId, RuleId allowingRuleId) {
    denyRuleToAllowRule.computeIf(denyingRuleId,
                                  ruleIdList -> (ruleIdList == null || !ruleIdList.contains(allowingRuleId)),
                                  (id, ruleIdList) -> {
                                      ArrayList<RuleId> newList = new ArrayList<>();
                                      if (ruleIdList != null) {
                                          newList.addAll(ruleIdList);
                                      }
                                      newList.add(allowingRuleId);
                                      return newList;
                                  });
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public void addRuleToDeviceMapping(RuleId ruleId, DeviceId deviceId) {
    ruleToDevice.computeIf(ruleId,
                           deviceIdSet -> (deviceIdSet == null || !deviceIdSet.contains(deviceId)),
                           (id, deviceIdSet) -> {
                               Set<DeviceId> newSet = new HashSet<>();
                               if (deviceIdSet != null) {
                                   newSet.addAll(deviceIdSet);
                               }
                               newSet.add(deviceId);
                               return newSet;
                           });
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
/**
 * Enforces removing an existing ACL rule.
 */
private void enforceRuleRemoving(RuleId ruleId) {
    Set<FlowRule> flowSet = aclStore.getFlowByRule(ruleId);
    if (flowSet != null) {
        for (FlowRule flowRule : flowSet) {
            flowRuleService.removeFlowRules(flowRule);
            log.debug("ACL flow rule {} is removed from {}.", flowRule.toString(), flowRule.deviceId().toString());
        }
    }
    aclStore.removeRuleToFlowMapping(ruleId);
    aclStore.removeRuleToDeviceMapping(ruleId);
    aclStore.removeDenyToAllowMapping(ruleId);
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Activate
public void activate() {
    ApplicationId appId = coreService.getAppId("org.onosproject.acl");

    KryoNamespace.Builder serializer = KryoNamespace.newBuilder()
            .register(KryoNamespaces.API)
            .register(AclRule.class)
            .register(AclRule.Action.class)
            .register(RuleId.class);

    ruleSet = storageService.<RuleId, AclRule>consistentMapBuilder()
            .withSerializer(Serializer.using(serializer.build()))
            .withName("acl-rule-set")
            .withApplicationId(appId)
            .withPurgeOnUninstall()
            .build();

    deviceToPriority = storageService.<DeviceId, Integer>consistentMapBuilder()
            .withSerializer(Serializer.using(serializer.build()))
            .withName("device-to-priority")
            .withApplicationId(appId)
            .withPurgeOnUninstall()
            .build();

    ruleToFlow = storageService.<RuleId, Set<FlowRule>>consistentMapBuilder()
            .withSerializer(Serializer.using(serializer.build()))
            .withName("rule-to-flow")
            .withApplicationId(appId)
            .withPurgeOnUninstall()
            .build();

    denyRuleToAllowRule = storageService.<RuleId, List<RuleId>>consistentMapBuilder()
            .withSerializer(Serializer.using(serializer.build()))
            .withName("deny-to-allow")
            .withApplicationId(appId)
            .withPurgeOnUninstall()
            .build();

    ruleToDevice = storageService.<RuleId, Set<DeviceId>>consistentMapBuilder()
            .withSerializer(Serializer.using(serializer.build()))
            .withName("rule-to-device")
            .withApplicationId(appId)
            .withPurgeOnUninstall()
            .build();

    log.info("Started");
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public void removeAclRule(RuleId ruleId) {
    ruleSet.remove(ruleId);
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public void removeRuleToFlowMapping(RuleId ruleId) {
    ruleToFlow.remove(ruleId);
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public void removeDenyToAllowMapping(RuleId denyingRuleId) {
    denyRuleToAllowRule.remove(denyingRuleId);
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public boolean checkIfRuleWorksInDevice(RuleId ruleId, DeviceId deviceId) {
    return ruleToDevice.containsKey(ruleId) && ruleToDevice.get(ruleId).value().contains(deviceId);
}
 

import org.onosproject.acl.RuleId; //导入依赖的package包/类
@Override
public void removeRuleToDeviceMapping(RuleId ruleId) {
    ruleToDevice.remove(ruleId);
}