Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2015 Open Networking Laboratory
   *
   * 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 org.onosproject.virtualbng;
 
 
 import java.io.File;
 import java.util.Map;
 
Implementation of ConfigurationService which reads virtual BNG configuration from a file.
 
 @Component(immediate = true)
 public class VbngConfigurationManager implements VbngConfigurationService {
 
     private final Logger log = LoggerFactory.getLogger(getClass());
 
     private static final String CONFIG_DIR = "../config";
     private static final String DEFAULT_CONFIG_FILE = "virtualbng.json";
 
     // If all the IP addresses of one IP prefix are assigned, then we
     // mark the value of this IP prefix as false, otherwise as true.
     private Map<IpPrefixBooleanlocalPublicIpPrefixes =
             new ConcurrentHashMap<>();
 
     // Map from private IP address to public IP address
     private Map<IpAddressIpAddressipAddressMap =
             new ConcurrentHashMap<>();
 
     private IpAddress nextHopIpAddress;
 
     @Activate
     public void activate() {
         readConfiguration();
         .info("vBNG configuration service started");
     }
 
     @Deactivate
     public void deactivate() {
         .info("vBNG configuration service stopped");
     }

    
Instructs the configuration reader to read the configuration from the file.
 
     public void readConfiguration() {
     }

    
Reads virtual BNG information contained in configuration file.

Parameters:
configFilename the name of the configuration file for the virtual BNG application
 
     private void readConfiguration(String configFilename) {
         File configFile = new File(configFilename);
         ObjectMapper mapper = new ObjectMapper();
 
         try {
             .info("Loading config: {}"configFile.getAbsolutePath());
             VbngConfiguration config = mapper.readValue(configFile,
                                                     VbngConfiguration.class);
             for (IpPrefix prefix : config.getLocalPublicIpPrefixes()) {
                 .put(prefixtrue);
            }
             = config.getNextHopIpAddress();
             = config.getPublicFacingMac();
        } catch (FileNotFoundException e) {
            .warn("Configuration file not found: {}");
        } catch (IOException e) {
            .error("Error loading configuration"e);
        }
    }
    @Override
    public IpAddress getNextHopIpAddress() {
        return ;
    }
    @Override
    public MacAddress getPublicFacingMac() {
        return ;
    }
    // TODO handle the case: the number of public IP addresses is not enough
    // for 1:1 mapping from public IP to private IP.
    @Override
    public synchronized IpAddress getAvailablePublicIpAddress(IpAddress
                                                           privateIpAddress) {
        // If there is already a mapping entry for the private IP address,
        // then fetch the public IP address in the mapping entry and return it.
        IpAddress publicIpAddress = .get(privateIpAddress);
        if (publicIpAddress != null) {
            return publicIpAddress;
        }
        // There is no mapping for the private IP address.
        Iterator<Entry<IpPrefixBoolean>> prefixes =
                .entrySet().iterator();
        while (prefixes.hasNext()) {
            Entry<IpPrefixBooleanprefix = prefixes.next();
            if (!prefix.getValue()) {
                continue;
            }
            if (prefix.getKey().prefixLength() == 32) {
                updateIpPrefixStatus(prefix.getKey(), false);
                publicIpAddress = prefix.getKey().address();
                .put(privateIpAddresspublicIpAddress);
                return publicIpAddress;
            }
            int prefixLen = prefix.getKey().prefixLength();
            int availableIpNum = (int) Math.pow(2,
                    . - prefixLen) - 1;
            for (int i = 1; i <= availableIpNumi++) {
                publicIpAddress =
                        increaseIpAddress(prefix.getKey().address(), i);
                if (publicIpAddress == null) {
                    return null;
                }
                if (.values().contains(publicIpAddress)) {
                    continue;
                } else if (i == availableIpNum) {
                    // All the IP addresses are assigned out
                    // Update this IP prefix status to false
                    // Note: in this version we do not consider the
                    // IP recycling issue.
                    updateIpPrefixStatus(prefix.getKey(), false);
                    .put(privateIpAddresspublicIpAddress);
                    return publicIpAddress;
                } else {
                    .put(privateIpAddresspublicIpAddress);
                    return publicIpAddress;
                }
            }
        }
        return null;
    }
    @Override
    public IpAddress getAssignedPublicIpAddress(IpAddress privateIpAddress) {
        return .get(privateIpAddress);
    }
    @Override
    public boolean isAssignedPublicIpAddress(IpAddress ipAddress) {
        return .containsValue(ipAddress);
    }
    @Override
                                                    privateIpAddress) {
        IpAddress publicIpAddress = .remove(privateIpAddress);
        if (publicIpAddress == null) {
            return null;
        }
        Iterator<Entry<IpPrefixBoolean>> prefixes =
                .entrySet().iterator();
        while (prefixes.hasNext()) {
            Entry<IpPrefixBooleanprefixEntry = prefixes.next();
            if (prefixEntry.getKey().contains(publicIpAddress)
                    && !prefixEntry.getValue()) {
                updateIpPrefixStatus(prefixEntry.getKey(), true);
            }
        }
        .info("[DELETE] Private IP to Public IP mapping: {} --> {}",
                 privateIpAddresspublicIpAddress);
        return publicIpAddress;
    }
    @Override
        return Collections.unmodifiableMap();
    }

    
Generates a new IP address base on a given IP address plus a number to increase.

Parameters:
ipAddress the IP address to increase
num the number for ipAddress to add
Returns:
the new IP address after increase
    private IpAddress increaseIpAddress(IpAddress ipAddressint num) {
        if (ipAddress.isIp6()) {
            .info("vBNG currently does not handle IPv6");
            return null;
        }
        return IpAddress.valueOf(ipAddress.getIp4Address().toInt() + num);
    }

    
Updates the IP prefix status in the local public IP prefix table.

Parameters:
ipPprefix the IP prefix to update
b the new value for the IP prefix
    private void updateIpPrefixStatus(IpPrefix ipPprefixboolean b) {
            .replace(ipPprefixb);
    }
New to GrepCode? Check out our FAQ X