홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
samanwita pal
Committed by Gerrit Code Review
f28207bd 1 parent fe565f28

Moving DHCP to onos branch. REST API included, GUI to be added later. 

Change-Id: Id52781ba93d48ad1d56097a9ceff7613a190c48e
Inline Side-by-side
Showing 21 changed files with 2922 additions and 0 deletions
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ Copyright 2014 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.
--><project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<artifactId>onos-apps</artifactId>
<groupId>org.onosproject</groupId>
<version>1.3.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<artifactId>onos-app-dhcp</artifactId>
<packaging>bundle</packaging>
<url>http://onosproject.org</url>
<description>DHCP Server application</description>
<properties>
<onos.app.name>org.onosproject.dhcp</onos.app.name>
<web.context>/onos/dhcp</web.context>
<api.version>1.0.0</api.version>
<api.title>DHCP Server REST API</api.title>
<api.description>
APIs for interacting with the DHCP Server application.
</api.description>
<api.package>org.onosproject.dhcp.rest</api.package>
</properties>
<dependencies>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.compendium</artifactId>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-cli</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.karaf.shell</groupId>
<artifactId>org.apache.karaf.shell.console</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onlab-junit</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-core-serializers</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-incubator-api</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-api</artifactId>
<version>${project.version}</version>
<classifier>tests</classifier>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-rest</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onlab-rest</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>javax.ws.rs</groupId>
<artifactId>jsr311-api</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-servlet</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
<extensions>true</extensions>
<configuration>
<instructions>
<_wab>src/main/webapp/</_wab>
<Include-Resource>
WEB-INF/classes/apidoc/swagger.json=target/swagger.json,
{maven-resources}
</Include-Resource>
<Bundle-SymbolicName>
${project.groupId}.${project.artifactId}
</Bundle-SymbolicName>
<Import-Package>
org.slf4j,
org.osgi.framework,
javax.ws.rs,
javax.ws.rs.core,
com.sun.jersey.api.core,
com.sun.jersey.spi.container.servlet,
com.sun.jersey.server.impl.container.servlet,
com.fasterxml.jackson.databind,
com.fasterxml.jackson.databind.node,
com.fasterxml.jackson.core,
org.apache.karaf.shell.commands,
org.apache.karaf.shell.console,
com.google.common.*,
org.onlab.packet.*,
org.onlab.rest.*,
org.onosproject.*,
org.onlab.util.*,
org.jboss.netty.util.*
</Import-Package>
<Web-ContextPath>${web.context}</Web-ContextPath>
</instructions>
</configuration>
</plugin>
</plugins>
</build>
</project>
/*
* Copyright 2014 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.dhcp;
import org.onlab.packet.Ip4Address;
import org.onlab.packet.MacAddress;
import java.util.Map;
/**
* DHCP Service Interface.
*/
public interface DHCPService {
/**
* Returns a collection of all the MacAddress to IPAddress mapping.
*
* @return collection of mappings.
*/
Map<MacAddress, Ip4Address> listMapping();
/**
* Returns the default lease time granted by the DHCP Server.
*
* @return lease time
*/
int getLeaseTime();
/**
* Returns the default renewal time granted by the DHCP Server.
*
* @return renewal time
*/
int getRenewalTime();
/**
* Returns the default rebinding time granted by the DHCP Server.
*
* @return rebinding time
*/
int getRebindingTime();
/**
* Registers a static IP mapping with the DHCP Server.
*
* @param macID macID of the client
* @param ipAddress IP Address requested for the client
* @return true if the mapping was successfully registered, false otherwise
*/
boolean setStaticMapping(MacAddress macID, Ip4Address ipAddress);
/**
* Removes a static IP mapping with the DHCP Server.
*
* @param macID macID of the client
* @return true if the mapping was successfully removed, false otherwise
*/
boolean removeStaticMapping(MacAddress macID);
/**
* Returns the list of all the available IPs with the server.
*
* @return list of available IPs
*/
Iterable<Ip4Address> getAvailableIPs();
}
/*
* Copyright 2014 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.dhcp;
import org.onlab.packet.Ip4Address;
import org.onlab.packet.MacAddress;
import java.util.Map;
/**
* DHCPStore Interface.
*/
public interface DHCPStore {
/**
* Appends all the IPs in a given range to the free pool of IPs.
*
* @param startIP Start IP for the range
* @param endIP End IP for the range
*/
void populateIPPoolfromRange(Ip4Address startIP, Ip4Address endIP);
/**
* Returns an IP Address for a Mac ID, in response to a DHCP DISCOVER message.
*
* @param macID Mac ID of the client requesting an IP
* @return IP address assigned to the Mac ID
*/
Ip4Address suggestIP(MacAddress macID, Ip4Address requestedIP);
/**
* Assigns the requested IP to the Mac ID, in response to a DHCP REQUEST message.
*
* @param macID Mac Id of the client requesting an IP
* @param ipAddr IP Address being requested
* @param leaseTime Lease time offered by the server for this mapping
* @return returns true if the assignment was successful, false otherwise
*/
boolean assignIP(MacAddress macID, Ip4Address ipAddr, int leaseTime);
/**
* Sets the default time for which suggested IP mappings are valid.
*
* @param timeInSeconds default time for IP mappings to be valid
*/
void setDefaultTimeoutForPurge(int timeInSeconds);
/**
* Sets the delay after which the dhcp server will purge expired entries.
*
* @param timeInSeconds default time
*/
void setTimerDelay(int timeInSeconds);
/**
* Releases the IP assigned to a Mac ID into the free pool.
*
* @param macID the macID for which the mapping needs to be changed
*/
void releaseIP(MacAddress macID);
/**
* Returns a collection of all the MacAddress to IPAddress mapping.
*
* @return the collection of the mappings
*/
Map<MacAddress, Ip4Address> listMapping();
/**
* Assigns the requested IP to the MAC ID (if available) for an indefinite period of time.
*
* @param macID macID of the client
* @param ipAddr IP Address requested for the client
* @return true if the mapping was successfully registered, false otherwise
*/
boolean assignStaticIP(MacAddress macID, Ip4Address ipAddr);
/**
* Removes a static IP mapping associated with the given MAC ID from the DHCP Server.
*
* @param macID macID of the client
* @return true if the mapping was successfully registered, false otherwise
*/
boolean removeStaticIP(MacAddress macID);
/**
* Returns the list of all the available IPs with the server.
*
* @return list of available IPs
*/
Iterable<Ip4Address> getAvailableIPs();
}
/*
* Copyright 2014 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.dhcp;
import com.google.common.base.MoreObjects;
import org.onlab.packet.Ip4Address;
import java.util.Date;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Stores the MAC ID to IP Address mapping details.
*/
public final class IPAssignment {
private final Ip4Address ipAddress;
private final Date timestamp;
private final long leasePeriod;
private final AssignmentStatus assignmentStatus;
public enum AssignmentStatus {
/**
* IP has been requested by a host, but not assigned to it yet.
*/
Option_Requested,
/**
* IP has been assigned to a host.
*/
Option_Assigned,
/**
* IP mapping is no longer active.
*/
Option_Expired;
}
/**
* Constructor for IPAssignment, where the ipAddress, the lease period, the timestamp
* and assignment status is supplied.
*
* @param ipAddress
* @param leasePeriod
* @param assignmentStatus
*/
private IPAssignment(Ip4Address ipAddress,
long leasePeriod,
Date timestamp,
AssignmentStatus assignmentStatus) {
this.ipAddress = ipAddress;
this.leasePeriod = leasePeriod;
this.timestamp = timestamp;
this.assignmentStatus = assignmentStatus;
}
/**
* Returns the IP Address of the IP assignment.
*
* @return the IP address
*/
public Ip4Address ipAddress() {
return this.ipAddress;
}
/**
* Returns the timestamp of the IP assignment.
*
* @return the timestamp
*/
public Date timestamp() {
return this.timestamp;
}
/**
* Returns the assignment status of the IP assignment.
*
* @return the assignment status
*/
public AssignmentStatus assignmentStatus() {
return this.assignmentStatus;
}
/**
* Returns the lease period of the IP assignment.
*
* @return the lease period
*/
public int leasePeriod() {
return (int) this.leasePeriod / 1000;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(getClass())
.add("ip", ipAddress)
.add("timestamp", timestamp)
.add("lease", leasePeriod)
.add("assignmentStatus", assignmentStatus)
.toString();
}
/**
* Creates and returns a new builder instance.
*
* @return new builder
*/
public static Builder builder() {
return new Builder();
}
/**
* Creates and returns a new builder instance that clones an existing IPAssignment.
*
* @return new builder
*/
public static Builder builder(IPAssignment assignment) {
return new Builder(assignment);
}
/**
* IPAssignment Builder.
*/
public static final class Builder {
private Ip4Address ipAddress;
private Date timeStamp;
private long leasePeriod;
private AssignmentStatus assignmentStatus;
private Builder() {
}
private Builder(IPAssignment ipAssignment) {
ipAddress = ipAssignment.ipAddress();
timeStamp = ipAssignment.timestamp();
leasePeriod = ipAssignment.leasePeriod() * 1000;
assignmentStatus = ipAssignment.assignmentStatus();
}
public IPAssignment build() {
validateInputs();
return new IPAssignment(ipAddress,
leasePeriod,
timeStamp,
assignmentStatus);
}
public Builder ipAddress(Ip4Address addr) {
ipAddress = addr;
return this;
}
public Builder timestamp(Date timestamp) {
timeStamp = timestamp;
return this;
}
public Builder leasePeriod(int leasePeriodinSeconds) {
leasePeriod = leasePeriodinSeconds * 1000;
return this;
}
public Builder assignmentStatus(AssignmentStatus status) {
assignmentStatus = status;
return this;
}
private void validateInputs() {
checkNotNull(ipAddress, "IP Address must be specified");
checkNotNull(assignmentStatus, "Assignment Status must be specified");
checkNotNull(leasePeriod, "Lease Period must be specified");
checkNotNull(timeStamp, "Timestamp must be specified");
switch (assignmentStatus) {
case Option_Requested:
case Option_Assigned:
case Option_Expired:
break;
default:
throw new IllegalStateException("Unknown assignment status");
}
}
}
}
/*
* Copyright 2014 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.dhcp.cli;
import org.apache.karaf.shell.commands.Command;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.dhcp.DHCPService;
/**
* Lists all the default lease parameters offered by the DHCP Server.
*/
@Command(scope = "onos", name = "dhcp-lease",
description = "Lists all the default lease parameters offered by the DHCP Server")
public class DHCPLeaseDetails extends AbstractShellCommand {
private static final String DHCP_LEASE_FORMAT = "Lease Time: %ds\nRenewal Time: %ds\nRebinding Time: %ds";
@Override
protected void execute() {
DHCPService dhcpService = AbstractShellCommand.get(DHCPService.class);
int leaseTime = dhcpService.getLeaseTime();
int renewTime = dhcpService.getRenewalTime();
int rebindTime = dhcpService.getRebindingTime();
print(DHCP_LEASE_FORMAT, leaseTime, renewTime, rebindTime);
}
}
/*
* Copyright 2014 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.dhcp.cli;
import org.apache.karaf.shell.commands.Command;
import org.onlab.packet.Ip4Address;
import org.onlab.packet.MacAddress;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.dhcp.DHCPService;
import java.util.Map;
/**
* Lists all the MacAddress to IP Address mappings held by the DHCP Server.
*/
@Command(scope = "onos", name = "dhcp-list",
description = "Lists all the MAC to IP mappings held by the DHCP Server")
public class DHCPListAllMappings extends AbstractShellCommand {
private static final String DHCP_MAPPING_FORMAT = "MAC ID: %s -> IP ASSIGNED %s";
@Override
protected void execute() {
DHCPService dhcpService = AbstractShellCommand.get(DHCPService.class);
Map<MacAddress, Ip4Address> allocationMap = dhcpService.listMapping();
for (Map.Entry<MacAddress, Ip4Address> entry : allocationMap.entrySet()) {
print(DHCP_MAPPING_FORMAT, entry.getKey().toString(), entry.getValue().toString());
}
}
}
/*
* Copyright 2014 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.dhcp.cli;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onlab.packet.MacAddress;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.dhcp.DHCPService;
/**
* Removes a static MAC Address to IP Mapping from the DHCP Server.
*/
@Command(scope = "onos", name = "dhcp-remove-static-mapping",
description = "Removes a static MAC Address to IP Mapping from the DHCP Server")
public class DHCPRemoveStaticMapping extends AbstractShellCommand {
@Argument(index = 0, name = "macAddr",
description = "MAC Address of the client",
required = true, multiValued = false)
String macAddr = null;
private static final String DHCP_SUCCESS = "Static Mapping Successfully Removed.";
private static final String DHCP_FAILURE = "Static Mapping Removal Failed. " +
"Either the mapping does not exist or it is not static.";
@Override
protected void execute() {
DHCPService dhcpService = AbstractShellCommand.get(DHCPService.class);
try {
MacAddress macID = MacAddress.valueOf(macAddr);
if (dhcpService.removeStaticMapping(macID)) {
print(DHCP_SUCCESS);
} else {
print(DHCP_FAILURE);
}
} catch (IllegalArgumentException e) {
print(e.getMessage());
}
}
}
/*
* Copyright 2014 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.dhcp.cli;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onlab.packet.Ip4Address;
import org.onlab.packet.MacAddress;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.dhcp.DHCPService;
/**
* Registers a static MAC Address to IP Mapping with the DHCP Server.
*/
@Command(scope = "onos", name = "dhcp-set-static-mapping",
description = "Registers a static MAC Address to IP Mapping with the DHCP Server")
public class DHCPSetStaticMapping extends AbstractShellCommand {
@Argument(index = 0, name = "macAddr",
description = "MAC Address of the client",
required = true, multiValued = false)
String macAddr = null;
@Argument(index = 1, name = "ipAddr",
description = "IP Address requested for static mapping",
required = true, multiValued = false)
String ipAddr = null;
private static final String DHCP_SUCCESS = "Static Mapping Successfully Added.";
private static final String DHCP_FAILURE = "Static Mapping Failed. The IP maybe unavailable.";
@Override
protected void execute() {
DHCPService dhcpService = AbstractShellCommand.get(DHCPService.class);
try {
MacAddress macID = MacAddress.valueOf(macAddr);
Ip4Address ipAddress = Ip4Address.valueOf(ipAddr);
if (dhcpService.setStaticMapping(macID, ipAddress)) {
print(DHCP_SUCCESS);
} else {
print(DHCP_FAILURE);
}
} catch (IllegalArgumentException e) {
print(e.getMessage());
}
}
}
/*
* Copyright 2014 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.dhcp.cli;
import org.apache.karaf.shell.console.Completer;
import org.apache.karaf.shell.console.completer.StringsCompleter;
import org.onlab.packet.Ip4Address;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.dhcp.DHCPService;
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
/**
* Free IP Completer.
*/
public class FreeIPCompleter implements Completer {
@Override
public int complete(String buffer, int cursor, List<String> candidates) {
// Delegate string completer
StringsCompleter delegate = new StringsCompleter();
DHCPService dhcpService = AbstractShellCommand.get(DHCPService.class);
Iterator<Ip4Address> it = dhcpService.getAvailableIPs().iterator();
SortedSet<String> strings = delegate.getStrings();
while (it.hasNext()) {
strings.add(it.next().toString());
}
// Now let the completer do the work for figuring out what to offer.
return delegate.complete(buffer, cursor, candidates);
}
}
/*
* Copyright 2014 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.dhcp.cli;
import org.apache.karaf.shell.console.Completer;
import org.apache.karaf.shell.console.completer.StringsCompleter;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.net.Host;
import org.onosproject.net.host.HostService;
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
/**
* MAC ID Completer.
*/
public class MacIdCompleter implements Completer {
@Override
public int complete(String buffer, int cursor, List<String> candidates) {
// Delegate string completer
StringsCompleter delegate = new StringsCompleter();
HostService service = AbstractShellCommand.get(HostService.class);
Iterator<Host> it = service.getHosts().iterator();
SortedSet<String> strings = delegate.getStrings();
while (it.hasNext()) {
strings.add(it.next().mac().toString());
}
// Now let the completer do the work for figuring out what to offer.
return delegate.complete(buffer, cursor, candidates);
}
}
/*
* Copyright 2014 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.dhcp.impl;
import org.onosproject.core.ApplicationId;
import org.onosproject.net.config.Config;
import org.onosproject.net.config.basics.BasicElementConfig;
/**
* DHCP Config class.
*/
public class DHCPConfig extends Config<ApplicationId> {
public static final String MY_IP = "ip";
public static final String MY_MAC = "mac";
public static final String SUBNET_MASK = "subnet";
public static final String BROADCAST_ADDRESS = "broadcast";
public static final String ROUTER_ADDRESS = "router";
public static final String DOMAIN_SERVER = "domain";
public static final String TTL = "ttl";
public static final String LEASE_TIME = "lease";
public static final String RENEW_TIME = "renew";
public static final String REBIND_TIME = "rebind";
/**
* Returns the dhcp server ip.
*
* @return ip address or null if not set
*/
public String ip() {
return get(MY_IP, null);
}
/**
* Sets the dhcp server ip.
*
* @param ip new ip address; null to clear
* @return self
*/
public BasicElementConfig ip(String ip) {
return (BasicElementConfig) setOrClear(MY_IP, ip);
}
/**
* Returns the dhcp server mac.
*
* @return server mac or null if not set
*/
public String mac() {
return get(MY_MAC, null);
}
/**
* Sets the dhcp server mac.
*
* @param mac new mac address; null to clear
* @return self
*/
public BasicElementConfig mac(String mac) {
return (BasicElementConfig) setOrClear(MY_MAC, mac);
}
/**
* Returns the subnet mask.
*
* @return subnet mask or null if not set
*/
public String subnetMask() {
return get(SUBNET_MASK, null);
}
/**
* Sets the subnet mask.
*
* @param subnet new subnet mask; null to clear
* @return self
*/
public BasicElementConfig subnetMask(String subnet) {
return (BasicElementConfig) setOrClear(SUBNET_MASK, subnet);
}
/**
* Returns the broadcast address.
*
* @return broadcast address or null if not set
*/
public String broadcastAddress() {
return get(BROADCAST_ADDRESS, null);
}
/**
* Sets the broadcast address.
*
* @param broadcast new broadcast address; null to clear
* @return self
*/
public BasicElementConfig broadcastAddress(String broadcast) {
return (BasicElementConfig) setOrClear(BROADCAST_ADDRESS, broadcast);
}
/**
* Returns the Time To Live for the reply packets.
*
* @return ttl or null if not set
*/
public String ttl() {
return get(TTL, null);
}
/**
* Sets the Time To Live for the reply packets.
*
* @param ttl new ttl; null to clear
* @return self
*/
public BasicElementConfig ttl(String ttl) {
return (BasicElementConfig) setOrClear(TTL, ttl);
}
/**
* Returns the Lease Time offered by the DHCP Server.
*
* @return lease time or null if not set
*/
public String leaseTime() {
return get(LEASE_TIME, null);
}
/**
* Sets the Lease Time offered by the DHCP Server.
*
* @param lease new lease time; null to clear
* @return self
*/
public BasicElementConfig leaseTime(String lease) {
return (BasicElementConfig) setOrClear(LEASE_TIME, lease);
}
/**
* Returns the Renew Time offered by the DHCP Server.
*
* @return renew time or null if not set
*/
public String renewTime() {
return get(RENEW_TIME, null);
}
/**
* Sets the Renew Time offered by the DHCP Server.
*
* @param renew new renew time; null to clear
* @return self
*/
public BasicElementConfig renewTime(String renew) {
return (BasicElementConfig) setOrClear(RENEW_TIME, renew);
}
/**
* Returns the Rebind Time offered by the DHCP Server.
*
* @return rebind time or null if not set
*/
public String rebindTime() {
return get(REBIND_TIME, null);
}
/**
* Sets the Rebind Time offered by the DHCP Server.
*
* @param rebind new rebind time; null to clear
* @return self
*/
public BasicElementConfig rebindTime(String rebind) {
return (BasicElementConfig) setOrClear(REBIND_TIME, rebind);
}
/**
* Returns the Router Address.
*
* @return router address or null if not set
*/
public String routerAddress() {
return get(ROUTER_ADDRESS, null);
}
/**
* Sets the Router Address.
*
* @param router new router address; null to clear
* @return self
*/
public BasicElementConfig routerAddress(String router) {
return (BasicElementConfig) setOrClear(ROUTER_ADDRESS, router);
}
/**
* Returns the Domain Server Address.
*
* @return domain server address or null if not set
*/
public String domainServer() {
return get(DOMAIN_SERVER, null);
}
/**
* Sets the Domain Server Address.
*
* @param domain new domain server address; null to clear
* @return self
*/
public BasicElementConfig domainServer(String domain) {
return (BasicElementConfig) setOrClear(DOMAIN_SERVER, domain);
}
}
/*
* Copyright 2014 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.dhcp.impl;
import com.google.common.collect.ImmutableSet;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
import org.onlab.packet.ARP;
import org.onlab.packet.DHCP;
import org.onlab.packet.DHCPOption;
import org.onlab.packet.Ethernet;
import org.onlab.packet.IPv4;
import org.onlab.packet.Ip4Address;
import org.onlab.packet.IpAddress;
import org.onlab.packet.MacAddress;
import org.onlab.packet.TpPort;
import org.onlab.packet.UDP;
import org.onlab.packet.VlanId;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
import org.onosproject.dhcp.DHCPService;
import org.onosproject.dhcp.DHCPStore;
import org.onosproject.net.config.ConfigFactory;
import org.onosproject.net.config.NetworkConfigEvent;
import org.onosproject.net.config.NetworkConfigListener;
import org.onosproject.net.config.NetworkConfigRegistry;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.Host;
import org.onosproject.net.HostId;
import org.onosproject.net.HostLocation;
import org.onosproject.net.flow.DefaultTrafficSelector;
import org.onosproject.net.flow.DefaultTrafficTreatment;
import org.onosproject.net.flow.TrafficSelector;
import org.onosproject.net.flow.TrafficTreatment;
import org.onosproject.net.host.DefaultHostDescription;
import org.onosproject.net.host.HostProvider;
import org.onosproject.net.host.HostProviderRegistry;
import org.onosproject.net.host.HostProviderService;
import org.onosproject.net.packet.DefaultOutboundPacket;
import org.onosproject.net.packet.PacketContext;
import org.onosproject.net.packet.PacketPriority;
import org.onosproject.net.packet.PacketProcessor;
import org.onosproject.net.packet.PacketService;
import org.onosproject.net.provider.AbstractProvider;
import org.onosproject.net.provider.ProviderId;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.onlab.packet.MacAddress.valueOf;
import static org.onosproject.net.config.basics.SubjectFactories.APP_SUBJECT_FACTORY;
/**
* Skeletal ONOS DHCP Server application.
*/
@Component(immediate = true)
@Service
public class DHCPManager implements DHCPService {
private static final ProviderId PID = new ProviderId("of", "org.onosproject.dhcp", true);
private final Logger log = LoggerFactory.getLogger(getClass());
private final NetworkConfigListener cfgListener = new InternalConfigListener();
private final Set<ConfigFactory> factories = ImmutableSet.of(
new ConfigFactory<ApplicationId, DHCPConfig>(APP_SUBJECT_FACTORY,
DHCPConfig.class,
"dhcp") {
@Override
public DHCPConfig createConfig() {
return new DHCPConfig();
}
},
new ConfigFactory<ApplicationId, DHCPStoreConfig>(APP_SUBJECT_FACTORY,
DHCPStoreConfig.class,
"dhcpstore") {
@Override
public DHCPStoreConfig createConfig() {
return new DHCPStoreConfig();
}
}
);
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected NetworkConfigRegistry cfgService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected PacketService packetService;
private DHCPPacketProcessor processor = new DHCPPacketProcessor();
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected CoreService coreService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected DHCPStore dhcpStore;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected HostProviderRegistry hostProviderRegistry;
protected HostProviderService hostProviderService;
private ApplicationId appId;
// Hardcoded values are default values.
private static String myIP = "10.0.0.2";
private static MacAddress myMAC = valueOf("4f:4f:4f:4f:4f:4f");
/**
* leaseTime - 10 mins or 600s.
* renewalTime - 5 mins or 300s.
* rebindingTime - 6 mins or 360s.
*/
private static int leaseTime = 600;
private static int renewalTime = 300;
private static int rebindingTime = 360;
private static byte packetTTL = (byte) 127;
private static String subnetMask = "255.0.0.0";
private static String broadcastAddress = "10.255.255.255";
private static String routerAddress = "10.0.0.2";
private static String domainServer = "10.0.0.2";
private final HostProvider hostProvider = new InternalHostProvider();
@Activate
protected void activate() {
// start the dhcp server
appId = coreService.registerApplication("org.onosproject.dhcp");
cfgService.addListener(cfgListener);
factories.forEach(cfgService::registerConfigFactory);
hostProviderService = hostProviderRegistry.register(hostProvider);
packetService.addProcessor(processor, PacketProcessor.observer(1));
requestPackets();
log.info("Started");
}
@Deactivate
protected void deactivate() {
cfgService.removeListener(cfgListener);
factories.forEach(cfgService::unregisterConfigFactory);
packetService.removeProcessor(processor);
hostProviderRegistry.unregister(hostProvider);
hostProviderService = null;
cancelPackets();
log.info("Stopped");
}
/**
* Request packet in via PacketService.
*/
private void requestPackets() {
TrafficSelector.Builder selectorServer = DefaultTrafficSelector.builder()
.matchEthType(Ethernet.TYPE_IPV4)
.matchIPProtocol(IPv4.PROTOCOL_UDP)
.matchUdpDst(TpPort.tpPort(UDP.DHCP_SERVER_PORT))
.matchUdpSrc(TpPort.tpPort(UDP.DHCP_CLIENT_PORT));
packetService.requestPackets(selectorServer.build(), PacketPriority.CONTROL, appId);
selectorServer = DefaultTrafficSelector.builder()
.matchEthType(Ethernet.TYPE_ARP);
packetService.requestPackets(selectorServer.build(), PacketPriority.CONTROL, appId);
}
/**
* Cancel requested packets in via packet service.
*/
private void cancelPackets() {
TrafficSelector.Builder selectorServer = DefaultTrafficSelector.builder()
.matchEthType(Ethernet.TYPE_IPV4)
.matchIPProtocol(IPv4.PROTOCOL_UDP)
.matchUdpDst(TpPort.tpPort(UDP.DHCP_SERVER_PORT))
.matchUdpSrc(TpPort.tpPort(UDP.DHCP_CLIENT_PORT));
packetService.cancelPackets(selectorServer.build(), PacketPriority.CONTROL, appId);
selectorServer = DefaultTrafficSelector.builder()
.matchEthType(Ethernet.TYPE_ARP);
packetService.cancelPackets(selectorServer.build(), PacketPriority.CONTROL, appId);
}
@Override
public Map<MacAddress, Ip4Address> listMapping() {
return dhcpStore.listMapping();
}
@Override
public int getLeaseTime() {
return leaseTime;
}
@Override
public int getRenewalTime() {
return renewalTime;
}
@Override
public int getRebindingTime() {
return rebindingTime;
}
@Override
public boolean setStaticMapping(MacAddress macID, Ip4Address ipAddress) {
return dhcpStore.assignStaticIP(macID, ipAddress);
}
@Override
public boolean removeStaticMapping(MacAddress macID) {
return dhcpStore.removeStaticIP(macID);
}
@Override
public Iterable<Ip4Address> getAvailableIPs() {
return dhcpStore.getAvailableIPs();
}
private class DHCPPacketProcessor implements PacketProcessor {
/**
* Builds the DHCP Reply packet.
*
* @param packet the incoming Ethernet frame
* @param ipOffered the IP offered by the DHCP Server
* @param outgoingMessageType the message type of the outgoing packet
* @return the Ethernet reply frame
*/
private Ethernet buildReply(Ethernet packet, String ipOffered, byte outgoingMessageType) {
Ip4Address myIPAddress = Ip4Address.valueOf(myIP);
Ip4Address ipAddress;
// Ethernet Frame.
Ethernet ethReply = new Ethernet();
ethReply.setSourceMACAddress(myMAC);
ethReply.setDestinationMACAddress(packet.getSourceMAC());
ethReply.setEtherType(Ethernet.TYPE_IPV4);
ethReply.setVlanID(packet.getVlanID());
// IP Packet
IPv4 ipv4Packet = (IPv4) packet.getPayload();
IPv4 ipv4Reply = new IPv4();
ipv4Reply.setSourceAddress(myIPAddress.toInt());
ipAddress = Ip4Address.valueOf(ipOffered);
ipv4Reply.setDestinationAddress(ipAddress.toInt());
ipv4Reply.setTtl(packetTTL);
// UDP Datagram.
UDP udpPacket = (UDP) ipv4Packet.getPayload();
UDP udpReply = new UDP();
udpReply.setSourcePort((byte) UDP.DHCP_SERVER_PORT);
udpReply.setDestinationPort((byte) UDP.DHCP_CLIENT_PORT);
// DHCP Payload.
DHCP dhcpPacket = (DHCP) udpPacket.getPayload();
DHCP dhcpReply = new DHCP();
dhcpReply.setOpCode(DHCP.OPCODE_REPLY);
ipAddress = Ip4Address.valueOf(ipOffered);
dhcpReply.setYourIPAddress(ipAddress.toInt());
dhcpReply.setServerIPAddress(myIPAddress.toInt());
dhcpReply.setTransactionId(dhcpPacket.getTransactionId());
dhcpReply.setClientHardwareAddress(dhcpPacket.getClientHardwareAddress());
dhcpReply.setHardwareType(DHCP.HWTYPE_ETHERNET);
dhcpReply.setHardwareAddressLength((byte) 6);
// DHCP Options.
DHCPOption option = new DHCPOption();
List<DHCPOption> optionList = new ArrayList<>();
// DHCP Message Type.
option.setCode(DHCP.DHCPOptionCode.OptionCode_MessageType.getValue());
option.setLength((byte) 1);
byte[] optionData = {outgoingMessageType};
option.setData(optionData);
optionList.add(option);
// DHCP Server Identifier.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_DHCPServerIp.getValue());
option.setLength((byte) 4);
option.setData(myIPAddress.toOctets());
optionList.add(option);
// IP Address Lease Time.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_LeaseTime.getValue());
option.setLength((byte) 4);
option.setData(ByteBuffer.allocate(4).putInt(leaseTime).array());
optionList.add(option);
// IP Address Renewal Time.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_RenewalTime.getValue());
option.setLength((byte) 4);
option.setData(ByteBuffer.allocate(4).putInt(renewalTime).array());
optionList.add(option);
// IP Address Rebinding Time.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OPtionCode_RebindingTime.getValue());
option.setLength((byte) 4);
option.setData(ByteBuffer.allocate(4).putInt(rebindingTime).array());
optionList.add(option);
// Subnet Mask.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_SubnetMask.getValue());
option.setLength((byte) 4);
ipAddress = Ip4Address.valueOf(subnetMask);
option.setData(ipAddress.toOctets());
optionList.add(option);
// Broadcast Address.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_BroadcastAddress.getValue());
option.setLength((byte) 4);
ipAddress = Ip4Address.valueOf(broadcastAddress);
option.setData(ipAddress.toOctets());
optionList.add(option);
// Router Address.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_RouterAddress.getValue());
option.setLength((byte) 4);
ipAddress = Ip4Address.valueOf(routerAddress);
option.setData(ipAddress.toOctets());
optionList.add(option);
// DNS Server Address.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_DomainServer.getValue());
option.setLength((byte) 4);
ipAddress = Ip4Address.valueOf(domainServer);
option.setData(ipAddress.toOctets());
optionList.add(option);
// End Option.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_END.getValue());
option.setLength((byte) 1);
optionList.add(option);
dhcpReply.setOptions(optionList);
udpReply.setPayload(dhcpReply);
ipv4Reply.setPayload(udpReply);
ethReply.setPayload(ipv4Reply);
return ethReply;
}
/**
* Sends the Ethernet reply frame via the Packet Service.
*
* @param context the context of the incoming frame
* @param reply the Ethernet reply frame
*/
private void sendReply(PacketContext context, Ethernet reply) {
if (reply != null) {
TrafficTreatment.Builder builder = DefaultTrafficTreatment.builder();
ConnectPoint sourcePoint = context.inPacket().receivedFrom();
builder.setOutput(sourcePoint.port());
packetService.emit(new DefaultOutboundPacket(sourcePoint.deviceId(),
builder.build(), ByteBuffer.wrap(reply.serialize())));
}
}
/**
* Processes the DHCP Payload and initiates a reply to the client.
*
* @param context context of the incoming message
* @param dhcpPayload the extracted DHCP payload
*/
private void processDHCPPacket(PacketContext context, DHCP dhcpPayload) {
Ethernet packet = context.inPacket().parsed();
boolean flagIfRequestedIP = false;
boolean flagIfServerIP = false;
Ip4Address requestedIP = Ip4Address.valueOf("0.0.0.0");
Ip4Address serverIP = Ip4Address.valueOf("0.0.0.0");
if (dhcpPayload != null) {
// TODO Convert this to enum value.
byte incomingPacketType = 0;
for (DHCPOption option : dhcpPayload.getOptions()) {
if (option.getCode() == DHCP.DHCPOptionCode.OptionCode_MessageType.getValue()) {
byte[] data = option.getData();
incomingPacketType = data[0];
}
if (option.getCode() == DHCP.DHCPOptionCode.OptionCode_RequestedIP.getValue()) {
byte[] data = option.getData();
requestedIP = Ip4Address.valueOf(data);
flagIfRequestedIP = true;
}
if (option.getCode() == DHCP.DHCPOptionCode.OptionCode_DHCPServerIp.getValue()) {
byte[] data = option.getData();
serverIP = Ip4Address.valueOf(data);
flagIfServerIP = true;
}
}
String ipOffered = "";
DHCP.DHCPMessageType outgoingPacketType;
MacAddress clientMAC = new MacAddress(dhcpPayload.getClientHardwareAddress());
if (incomingPacketType == DHCP.DHCPMessageType.MessageType_Discover.getValue()) {
outgoingPacketType = DHCP.DHCPMessageType.MessageType_Offer;
ipOffered = dhcpStore.suggestIP(clientMAC, requestedIP).toString();
Ethernet ethReply = buildReply(packet, ipOffered, outgoingPacketType.getValue());
sendReply(context, ethReply);
} else if (incomingPacketType == DHCP.DHCPMessageType.MessageType_Request.getValue()) {
outgoingPacketType = DHCP.DHCPMessageType.MessageType_ACK;
if (flagIfServerIP && flagIfRequestedIP) {
// SELECTING state
if (myIP.equals(serverIP.toString()) &&
dhcpStore.assignIP(clientMAC, requestedIP, leaseTime)) {
Ethernet ethReply = buildReply(packet, requestedIP.toString(),
outgoingPacketType.getValue());
sendReply(context, ethReply);
discoverHost(context, requestedIP);
}
} else if (flagIfRequestedIP) {
// INIT-REBOOT state
if (dhcpStore.assignIP(clientMAC, requestedIP, leaseTime)) {
Ethernet ethReply = buildReply(packet, requestedIP.toString(),
outgoingPacketType.getValue());
sendReply(context, ethReply);
discoverHost(context, requestedIP);
}
} else {
// RENEWING and REBINDING state
int ciaadr = dhcpPayload.getClientIPAddress();
if (ciaadr != 0) {
Ip4Address clientIaddr = Ip4Address.valueOf(ciaadr);
if (dhcpStore.assignIP(clientMAC, clientIaddr, leaseTime)) {
Ethernet ethReply = buildReply(packet, clientIaddr.toString(),
outgoingPacketType.getValue());
sendReply(context, ethReply);
discoverHost(context, clientIaddr);
}
}
}
} else if (incomingPacketType == DHCP.DHCPMessageType.MessageType_Release.getValue()) {
dhcpStore.releaseIP(clientMAC);
}
}
}
/**
* Processes the ARP Payload and initiates a reply to the client.
*
* @param context context of the incoming message
* @param packet the ethernet payload
*/
private void processARPPacket(PacketContext context, Ethernet packet) {
ARP arpPacket = (ARP) packet.getPayload();
ARP arpReply = (ARP) arpPacket.clone();
arpReply.setOpCode(ARP.OP_REPLY);
arpReply.setTargetProtocolAddress(arpPacket.getSenderProtocolAddress());
arpReply.setTargetHardwareAddress(arpPacket.getSenderHardwareAddress());
arpReply.setSenderProtocolAddress(arpPacket.getTargetProtocolAddress());
arpReply.setSenderHardwareAddress(myMAC.toBytes());
// Ethernet Frame.
Ethernet ethReply = new Ethernet();
ethReply.setSourceMACAddress(myMAC);
ethReply.setDestinationMACAddress(packet.getSourceMAC());
ethReply.setEtherType(Ethernet.TYPE_ARP);
ethReply.setVlanID(packet.getVlanID());
ethReply.setPayload(arpReply);
sendReply(context, ethReply);
}
/**
* Integrates hosts learned through DHCP into topology.
* @param context context of the incoming message
* @param ipAssigned IP Address assigned to the host by DHCP Manager
*/
private void discoverHost(PacketContext context, Ip4Address ipAssigned) {
Ethernet packet = context.inPacket().parsed();
MacAddress mac = packet.getSourceMAC();
VlanId vlanId = VlanId.vlanId(packet.getVlanID());
HostLocation hostLocation = new HostLocation(context.inPacket().receivedFrom(), 0);
Set<IpAddress> ips = new HashSet<>();
ips.add(ipAssigned);
HostId hostId = HostId.hostId(mac, vlanId);
DefaultHostDescription desc = new DefaultHostDescription(mac, vlanId, hostLocation, ips);
hostProviderService.hostDetected(hostId, desc);
}
@Override
public void process(PacketContext context) {
Ethernet packet = context.inPacket().parsed();
if (packet == null) {
return;
}
if (packet.getEtherType() == Ethernet.TYPE_IPV4) {
IPv4 ipv4Packet = (IPv4) packet.getPayload();
if (ipv4Packet.getProtocol() == IPv4.PROTOCOL_UDP) {
UDP udpPacket = (UDP) ipv4Packet.getPayload();
if (udpPacket.getDestinationPort() == UDP.DHCP_SERVER_PORT &&
udpPacket.getSourcePort() == UDP.DHCP_CLIENT_PORT) {
// This is meant for the dhcp server so process the packet here.
DHCP dhcpPayload = (DHCP) udpPacket.getPayload();
processDHCPPacket(context, dhcpPayload);
}
}
} else if (packet.getEtherType() == Ethernet.TYPE_ARP) {
ARP arpPacket = (ARP) packet.getPayload();
if ((arpPacket.getOpCode() == ARP.OP_REQUEST) &&
(Ip4Address.valueOf(arpPacket.getTargetProtocolAddress()).toString().equals(myIP))) {
processARPPacket(context, packet);
}
}
}
}
private class InternalConfigListener implements NetworkConfigListener {
/**
* Reconfigures the DHCP Server according to the configuration parameters passed.
*
* @param cfg configuration object
*/
private void reconfigureNetwork(DHCPConfig cfg) {
if (cfg.ip() != null) {
myIP = cfg.ip();
}
if (cfg.mac() != null) {
myMAC = MacAddress.valueOf(cfg.mac());
}
if (cfg.subnetMask() != null) {
subnetMask = cfg.subnetMask();
}
if (cfg.broadcastAddress() != null) {
broadcastAddress = cfg.broadcastAddress();
}
if (cfg.routerAddress() != null) {
routerAddress = cfg.routerAddress();
}
if (cfg.domainServer() != null) {
domainServer = cfg.domainServer();
}
if (cfg.ttl() != null) {
packetTTL = Byte.valueOf(cfg.ttl());
}
if (cfg.leaseTime() != null) {
leaseTime = Integer.valueOf(cfg.leaseTime());
}
if (cfg.renewTime() != null) {
renewalTime = Integer.valueOf(cfg.renewTime());
}
if (cfg.rebindTime() != null) {
rebindingTime = Integer.valueOf(cfg.rebindTime());
}
}
/**
* Reconfigures the DHCP Store according to the configuration parameters passed.
*
* @param cfg configuration object
*/
private void reconfigureStore(DHCPStoreConfig cfg) {
if (cfg.defaultTimeout() != null) {
dhcpStore.setDefaultTimeoutForPurge(Integer.valueOf(cfg.defaultTimeout()));
}
if (cfg.timerDelay() != null) {
dhcpStore.setTimerDelay(Integer.valueOf(cfg.defaultTimeout()));
}
if ((cfg.startIP() != null) && (cfg.endIP() != null)) {
dhcpStore.populateIPPoolfromRange(Ip4Address.valueOf(cfg.startIP()),
Ip4Address.valueOf(cfg.endIP()));
}
}
@Override
public void event(NetworkConfigEvent event) {
if ((event.type() == NetworkConfigEvent.Type.CONFIG_ADDED ||
event.type() == NetworkConfigEvent.Type.CONFIG_UPDATED)) {
if (event.configClass().equals(DHCPConfig.class)) {
DHCPConfig cfg = cfgService.getConfig(appId, DHCPConfig.class);
reconfigureNetwork(cfg);
log.info("Reconfigured Manager");
}
if (event.configClass().equals(DHCPStoreConfig.class)) {
DHCPStoreConfig cfg = cfgService.getConfig(appId, DHCPStoreConfig.class);
reconfigureStore(cfg);
log.info("Reconfigured Store");
}
}
}
}
private class InternalHostProvider extends AbstractProvider implements HostProvider {
/**
* Creates a provider with the supplier identifier.
*/
protected InternalHostProvider() {
super(PID);
}
@Override
public void triggerProbe(Host host) {
// nothing to do
}
}
}
\ No newline at end of file
/*
* Copyright 2014 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.dhcp.impl;
import org.onosproject.core.ApplicationId;
import org.onosproject.net.config.Config;
import org.onosproject.net.config.basics.BasicElementConfig;
/**
* DHCP Store Config class.
*/
public class DHCPStoreConfig extends Config<ApplicationId> {
public static final String TIMER_DELAY = "delay";
public static final String DEFAULT_TIMEOUT = "timeout";
public static final String START_IP = "startip";
public static final String END_IP = "endip";
/**
* Returns the delay after which the dhcp server will purge expired entries.
*
* @return time delay or null if not set
*/
public String timerDelay() {
return get(TIMER_DELAY, null);
}
/**
* Sets the delay after which the dhcp server will purge expired entries.
*
* @param delay new time delay; null to clear
* @return self
*/
public BasicElementConfig timerDelay(String delay) {
return (BasicElementConfig) setOrClear(TIMER_DELAY, delay);
}
/**
* Returns the default timeout for pending assignments.
*
* @return default timeout or null if not set
*/
public String defaultTimeout() {
return get(DEFAULT_TIMEOUT, null);
}
/**
* Sets the default timeout for pending assignments.
*
* @param defaultTimeout new default timeout; null to clear
* @return self
*/
public BasicElementConfig defaultTimeout(String defaultTimeout) {
return (BasicElementConfig) setOrClear(DEFAULT_TIMEOUT, defaultTimeout);
}
/**
* Returns the start IP for the available IP Range.
*
* @return start IP or null if not set
*/
public String startIP() {
return get(START_IP, null);
}
/**
* Sets the start IP for the available IP Range.
*
* @param startIP new start IP; null to clear
* @return self
*/
public BasicElementConfig startIP(String startIP) {
return (BasicElementConfig) setOrClear(START_IP, startIP);
}
/**
* Returns the end IP for the available IP Range.
*
* @return end IP or null if not set
*/
public String endIP() {
return get(END_IP, null);
}
/**
* Sets the end IP for the available IP Range.
*
* @param endIP new end IP; null to clear
* @return self
*/
public BasicElementConfig endIP(String endIP) {
return (BasicElementConfig) setOrClear(END_IP, endIP);
}
}
/*
* Copyright 2014 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.dhcp.impl;
import com.google.common.collect.ImmutableSet;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
import org.jboss.netty.util.Timeout;
import org.jboss.netty.util.TimerTask;
import org.onlab.packet.Ip4Address;
import org.onlab.packet.MacAddress;
import org.onlab.util.KryoNamespace;
import org.onlab.util.Timer;
import org.onosproject.dhcp.DHCPStore;
import org.onosproject.dhcp.IPAssignment;
import org.onosproject.store.serializers.KryoNamespaces;
import org.onosproject.store.service.ConsistentMap;
import org.onosproject.store.service.DistributedSet;
import org.onosproject.store.service.Serializer;
import org.onosproject.store.service.StorageService;
import org.onosproject.store.service.Versioned;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
* Manages the pool of available IP Addresses in the network and
* Remembers the mapping between MAC ID and IP Addresses assigned.
*/
@Component(immediate = true)
@Service
public class DistributedDHCPStore implements DHCPStore {
private final Logger log = LoggerFactory.getLogger(getClass());
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected StorageService storageService;
private ConsistentMap<MacAddress, IPAssignment> allocationMap;
private DistributedSet<Ip4Address> freeIPPool;
private Timeout timeout;
private static Ip4Address startIPRange;
private static Ip4Address endIPRange;
// Hardcoded values are default values.
private static int timerDelay = 2;
private static int timeoutForPendingAssignments = 60;
@Activate
protected void activate() {
allocationMap = storageService.<MacAddress, IPAssignment>consistentMapBuilder()
.withName("onos-dhcp-assignedIP")
.withSerializer(Serializer.using(
new KryoNamespace.Builder()
.register(KryoNamespaces.API)
.register(IPAssignment.class,
IPAssignment.AssignmentStatus.class,
Date.class,
long.class,
Ip4Address.class)
.build()))
.build();
freeIPPool = storageService.<Ip4Address>setBuilder()
.withName("onos-dhcp-freeIP")
.withSerializer(Serializer.using(KryoNamespaces.API))
.build();
timeout = Timer.getTimer().newTimeout(new PurgeListTask(), timerDelay, TimeUnit.MINUTES);
log.info("Started");
}
@Deactivate
protected void deactivate() {
timeout.cancel();
log.info("Stopped");
}
@Override
public Ip4Address suggestIP(MacAddress macID, Ip4Address requestedIP) {
IPAssignment assignmentInfo;
if (allocationMap.containsKey(macID)) {
assignmentInfo = allocationMap.get(macID).value();
IPAssignment.AssignmentStatus status = assignmentInfo.assignmentStatus();
Ip4Address ipAddr = assignmentInfo.ipAddress();
if (status == IPAssignment.AssignmentStatus.Option_Assigned ||
status == IPAssignment.AssignmentStatus.Option_Requested) {
// Client has a currently Active Binding.
if ((ipAddr.toInt() > startIPRange.toInt()) && (ipAddr.toInt() < endIPRange.toInt())) {
return ipAddr;
}
} else if (status == IPAssignment.AssignmentStatus.Option_Expired) {
// Client has a Released or Expired Binding.
if (freeIPPool.contains(ipAddr)) {
assignmentInfo = IPAssignment.builder()
.ipAddress(ipAddr)
.timestamp(new Date())
.leasePeriod(timeoutForPendingAssignments)
.assignmentStatus(IPAssignment.AssignmentStatus.Option_Requested)
.build();
if (freeIPPool.remove(ipAddr)) {
allocationMap.put(macID, assignmentInfo);
return ipAddr;
}
}
}
return assignmentInfo.ipAddress();
} else if (requestedIP.toInt() != 0) {
// Client has requested an IP.
if (freeIPPool.contains(requestedIP)) {
assignmentInfo = IPAssignment.builder()
.ipAddress(requestedIP)
.timestamp(new Date())
.leasePeriod(timeoutForPendingAssignments)
.assignmentStatus(IPAssignment.AssignmentStatus.Option_Requested)
.build();
if (freeIPPool.remove(requestedIP)) {
allocationMap.put(macID, assignmentInfo);
return requestedIP;
}
}
}
// Allocate a new IP from the server's pool of available IP.
Ip4Address nextIPAddr = fetchNextIP();
assignmentInfo = IPAssignment.builder()
.ipAddress(nextIPAddr)
.timestamp(new Date())
.leasePeriod(timeoutForPendingAssignments)
.assignmentStatus(IPAssignment.AssignmentStatus.Option_Requested)
.build();
allocationMap.put(macID, assignmentInfo);
return nextIPAddr;
}
@Override
public boolean assignIP(MacAddress macID, Ip4Address ipAddr, int leaseTime) {
IPAssignment assignmentInfo;
if (allocationMap.containsKey(macID)) {
assignmentInfo = allocationMap.get(macID).value();
if ((assignmentInfo.ipAddress().toInt() == ipAddr.toInt()) &&
(ipAddr.toInt() > startIPRange.toInt()) && (ipAddr.toInt() < endIPRange.toInt())) {
assignmentInfo = IPAssignment.builder()
.ipAddress(ipAddr)
.timestamp(new Date())
.leasePeriod(leaseTime)
.assignmentStatus(IPAssignment.AssignmentStatus.Option_Assigned)
.build();
allocationMap.put(macID, assignmentInfo);
return true;
}
} else if (freeIPPool.contains(ipAddr)) {
assignmentInfo = IPAssignment.builder()
.ipAddress(ipAddr)
.timestamp(new Date())
.leasePeriod(leaseTime)
.assignmentStatus(IPAssignment.AssignmentStatus.Option_Assigned)
.build();
if (freeIPPool.remove(ipAddr)) {
allocationMap.put(macID, assignmentInfo);
return true;
}
}
return false;
}
@Override
public void releaseIP(MacAddress macID) {
if (allocationMap.containsKey(macID)) {
IPAssignment newAssignment = IPAssignment.builder(allocationMap.get(macID).value())
.assignmentStatus(IPAssignment.AssignmentStatus.Option_Expired)
.build();
Ip4Address freeIP = newAssignment.ipAddress();
allocationMap.put(macID, newAssignment);
freeIPPool.add(freeIP);
}
}
@Override
public void setDefaultTimeoutForPurge(int timeInSeconds) {
timeoutForPendingAssignments = timeInSeconds;
}
@Override
public void setTimerDelay(int timeInSeconds) {
timerDelay = timeInSeconds;
}
@Override
public Map<MacAddress, Ip4Address> listMapping() {
Map<MacAddress, Ip4Address> allMapping = new HashMap<>();
for (Map.Entry<MacAddress, Versioned<IPAssignment>> entry: allocationMap.entrySet()) {
IPAssignment assignment = entry.getValue().value();
if (assignment.assignmentStatus() == IPAssignment.AssignmentStatus.Option_Assigned) {
allMapping.put(entry.getKey(), assignment.ipAddress());
}
}
return allMapping;
}
@Override
public boolean assignStaticIP(MacAddress macID, Ip4Address ipAddr) {
return assignIP(macID, ipAddr, -1);
}
@Override
public boolean removeStaticIP(MacAddress macID) {
if (allocationMap.containsKey(macID)) {
IPAssignment assignment = allocationMap.get(macID).value();
Ip4Address freeIP = assignment.ipAddress();
if (assignment.leasePeriod() < 0) {
allocationMap.remove(macID);
freeIPPool.add(freeIP);
return true;
}
}
return false;
}
@Override
public Iterable<Ip4Address> getAvailableIPs() {
return ImmutableSet.<Ip4Address>copyOf(freeIPPool);
}
@Override
public void populateIPPoolfromRange(Ip4Address startIP, Ip4Address endIP) {
// Clear all entries from previous range.
startIPRange = startIP;
endIPRange = endIP;
freeIPPool.clear();
int lastIP = endIP.toInt();
Ip4Address nextIP;
for (int loopCounter = startIP.toInt(); loopCounter <= lastIP; loopCounter++) {
nextIP = Ip4Address.valueOf(loopCounter);
freeIPPool.add(nextIP);
}
}
/**
* Fetches the next available IP from the free pool pf IPs.
*
* @return the next available IP address
*/
private Ip4Address fetchNextIP() {
for (Ip4Address freeIP : freeIPPool) {
if (freeIPPool.remove(freeIP)) {
return freeIP;
}
}
return null;
}
/**
* Purges the IP allocation map to remove expired entries and returns the freed IPs to the free pool.
*/
private class PurgeListTask implements TimerTask {
@Override
public void run(Timeout to) {
IPAssignment ipAssignment, newAssignment;
Date dateNow = new Date();
for (Map.Entry<MacAddress, Versioned<IPAssignment>> entry: allocationMap.entrySet()) {
ipAssignment = entry.getValue().value();
long timeLapsed = dateNow.getTime() - ipAssignment.timestamp().getTime();
if ((ipAssignment.assignmentStatus() != IPAssignment.AssignmentStatus.Option_Expired) &&
(ipAssignment.leasePeriod() > 0) && (timeLapsed > (ipAssignment.leasePeriod()))) {
Ip4Address freeIP = ipAssignment.ipAddress();
newAssignment = IPAssignment.builder(ipAssignment)
.assignmentStatus(IPAssignment.AssignmentStatus.Option_Expired)
.build();
allocationMap.put(entry.getKey(), newAssignment);
if ((freeIP.toInt() > startIPRange.toInt()) && (freeIP.toInt() < endIPRange.toInt())) {
freeIPPool.add(freeIP);
}
}
}
timeout = Timer.getTimer().newTimeout(new PurgeListTask(), timerDelay, TimeUnit.MINUTES);
}
}
}
/*
* 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.dhcp.rest;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.onlab.packet.Ip4Address;
import org.onlab.packet.MacAddress;
import org.onosproject.dhcp.DHCPService;
import org.onosproject.rest.AbstractWebResource;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
/**
* Manage DHCP address assignments.
*/
@Path("dhcp")
public class DHCPWebResource extends AbstractWebResource {
final DHCPService service = get(DHCPService.class);
/**
* Get DHCP server configuration data.
* Shows lease, renewal and rebinding times in seconds.
*
* @return 200 OK
*/
@GET
@Path("config")
public Response getConfigs() {
DHCPService service = get(DHCPService.class);
ObjectNode node = mapper().createObjectNode()
.put("leaseTime", service.getLeaseTime())
.put("renewalTime", service.getRenewalTime())
.put("rebindingTime", service.getRebindingTime());
return ok(node.toString()).build();
}
/**
* Get all MAC/IP mappings.
* Shows all MAC/IP mappings held by the DHCP server.
*
* @return 200 OK
*/
@GET
@Path("mappings")
public Response listMappings() {
ObjectNode root = mapper().createObjectNode();
final Map<MacAddress, Ip4Address> intents = service.listMapping();
ArrayNode arrayNode = root.putArray("mappings");
intents.entrySet().forEach(i -> arrayNode.add(mapper().createObjectNode()
.put("mac", i.getKey().toString())
.put("ip", i.getValue().toString())));
return ok(root.toString()).build();
}
/**
* Get all available IPs.
* Shows all the IPs in the free pool of the DHCP Server.
*
* @return 200 OK
*/
@GET
@Path("available")
public Response listAvailableIPs() {
final Iterable<Ip4Address> availableIPList = service.getAvailableIPs();
final ObjectNode root = mapper().createObjectNode();
ArrayNode arrayNode = root.putArray("availableIP");
availableIPList.forEach(i -> arrayNode.add(i.toString()));
return ok(root.toString()).build();
}
/**
* Post a new static MAC/IP binding.
* Registers a static binding to the DHCP server, and displays the current set of bindings.
*
* @return 200 OK
*/
@POST
@Path("mappings")
@Consumes(MediaType.APPLICATION_JSON)
public Response setMapping(InputStream stream) {
ObjectNode root = mapper().createObjectNode();
try {
ObjectNode jsonTree = (ObjectNode) mapper().readTree(stream);
JsonNode macID = jsonTree.get("mac");
JsonNode ip = jsonTree.get("ip");
if (macID != null && ip != null) {
if (!service.setStaticMapping(MacAddress.valueOf(macID.asText()),
Ip4Address.valueOf(ip.asText()))) {
throw new IllegalArgumentException("Static Mapping Failed. The IP maybe unavailable.");
}
}
final Map<MacAddress, Ip4Address> intents = service.listMapping();
ArrayNode arrayNode = root.putArray("mappings");
intents.entrySet().forEach(i -> arrayNode.add(mapper().createObjectNode()
.put("mac", i.getKey().toString())
.put("ip", i.getValue().toString())));
} catch (IOException e) {
throw new IllegalArgumentException(e.getMessage());
}
return ok(root.toString()).build();
}
/**
* Delete a static MAC/IP binding.
* Removes a static binding from the DHCP Server, and displays the current set of bindings.
*
* @return 200 OK
*/
@DELETE
@Path("mappings/{macID}")
public Response deleteMapping(@PathParam("macID") String macID) {
ObjectNode root = mapper().createObjectNode();
if (!service.removeStaticMapping(MacAddress.valueOf(macID))) {
throw new IllegalArgumentException("Static Mapping Removal Failed.");
}
final Map<MacAddress, Ip4Address> intents = service.listMapping();
ArrayNode arrayNode = root.putArray("mappings");
intents.entrySet().forEach(i -> arrayNode.add(mapper().createObjectNode()
.put("mac", i.getKey().toString())
.put("ip", i.getValue().toString())));
return ok(root.toString()).build();
}
}
<!--
~ Copyright 2014 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.
-->
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
<command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
<command>
<action class="org.onosproject.dhcp.cli.DHCPListAllMappings"/>
</command>
<command>
<action class="org.onosproject.dhcp.cli.DHCPLeaseDetails"/>
</command>
<command>
<action class="org.onosproject.dhcp.cli.DHCPSetStaticMapping"/>
<completers>
<ref component-id="macIDCompleter"/>
<ref component-id="freeIPCompleter"/>
</completers>
</command>
<command>
<action class="org.onosproject.dhcp.cli.DHCPRemoveStaticMapping"/>
<completers>
<ref component-id="macIDCompleter"/>
</completers>
</command>
</command-bundle>
<bean id="macIDCompleter" class="org.onosproject.dhcp.cli.MacIdCompleter"/>
<bean id="freeIPCompleter" class="org.onosproject.dhcp.cli.FreeIPCompleter"/>
</blueprint>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ 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.
-->
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="ONOS" version="2.5">
<display-name>DHCP Server REST API v1.0</display-name>
<servlet>
<servlet-name>JAX-RS Service</servlet-name>
<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>com.sun.jersey.config.property.resourceConfigClass</param-name>
<param-value>com.sun.jersey.api.core.ClassNamesResourceConfig</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.config.property.classnames</param-name>
<param-value>
org.onosproject.dhcp.rest.DHCPWebResource
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>JAX-RS Service</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
/*
* Copyright 2014 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.dhcp;
import com.google.common.testing.EqualsTester;
import junit.framework.TestCase;
import org.junit.Assert;
import org.junit.Test;
import org.onlab.packet.Ip4Address;
import java.util.Date;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.fail;
/**
* Unit Tests for IPAssignment class.
*/
public class IPAssignmentTest extends TestCase {
private final Date dateNow = new Date();
private final IPAssignment stats1 = IPAssignment.builder()
.ipAddress(Ip4Address.valueOf("10.10.10.10"))
.leasePeriod(300)
.assignmentStatus(IPAssignment.AssignmentStatus.Option_Expired)
.timestamp(dateNow)
.build();
private final IPAssignment stats2 = IPAssignment.builder()
.ipAddress(Ip4Address.valueOf("10.10.10.10"))
.leasePeriod(300)
.assignmentStatus(IPAssignment.AssignmentStatus.Option_Assigned)
.timestamp(dateNow)
.build();
private final IPAssignment stats3 = IPAssignment.builder(stats1)
.build();
/**
* Tests the constructor for the class.
*/
@Test
public void testConstruction() {
assertThat(stats3.ipAddress(), is(Ip4Address.valueOf("10.10.10.10")));
assertThat(stats3.timestamp(), is(dateNow));
assertThat(stats3.leasePeriod(), is(300));
assertThat(stats3.assignmentStatus(), is(IPAssignment.AssignmentStatus.Option_Expired));
}
/**
* Tests the equality and inequality of objects using Guava EqualsTester.
*/
@Test
public void testEquals() {
new EqualsTester()
.addEqualityGroup(stats1, stats1)
.addEqualityGroup(stats2)
.testEquals();
}
/**
* Tests if the toString method returns a consistent value for hashing.
*/
@Test
public void testToString() {
assertThat(stats1.toString(), is(stats1.toString()));
}
/**
* Tests if the validateInputs method returns an exception for malformed object.
*/
@Test
public void testValidateInputs() {
try {
IPAssignment stats4 = IPAssignment.builder()
.ipAddress(Ip4Address.valueOf("10.10.10.10"))
.leasePeriod(300)
.build();
fail("Construction of a malformed IPAssignment did not throw an exception");
} catch (NullPointerException e) {
Assert.assertThat(e.getMessage(), containsString("must be specified"));
}
}
}
\ No newline at end of file
/*
* Copyright 2014 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.dhcp.impl;
import com.google.common.collect.ImmutableSet;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.onlab.packet.DHCP;
import org.onlab.packet.DHCPOption;
import org.onlab.packet.Ethernet;
import org.onlab.packet.IPv4;
import org.onlab.packet.Ip4Address;
import org.onlab.packet.MacAddress;
import org.onlab.packet.UDP;
import org.onosproject.core.CoreServiceAdapter;
import org.onosproject.dhcp.DHCPStore;
import org.onosproject.net.config.NetworkConfigRegistryAdapter;
import org.onosproject.net.Host;
import org.onosproject.net.HostId;
import org.onosproject.net.host.HostDescription;
import org.onosproject.net.host.HostProvider;
import org.onosproject.net.host.HostProviderRegistry;
import org.onosproject.net.host.HostProviderService;
import org.onosproject.net.packet.DefaultInboundPacket;
import org.onosproject.net.packet.DefaultPacketContext;
import org.onosproject.net.packet.InboundPacket;
import org.onosproject.net.packet.OutboundPacket;
import org.onosproject.net.packet.PacketContext;
import org.onosproject.net.packet.PacketProcessor;
import org.onosproject.net.packet.PacketServiceAdapter;
import org.onosproject.net.provider.AbstractProvider;
import org.onosproject.net.provider.AbstractProviderService;
import org.onosproject.net.provider.ProviderId;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.onosproject.net.NetTestTools.connectPoint;
/**
* Set of tests of the ONOS application component.
*/
public class DHCPManagerTest {
private DHCPManager dhcpManager;
protected PacketProcessor packetProcessor;
protected HostProviderService hostProviderService;
private static final MacAddress CLIENT1_MAC = MacAddress.valueOf("1a:1a:1a:1a:1a:1a");
private static final String EXPECTED_IP = "10.2.0.2";
private static final Ip4Address BROADCAST = Ip4Address.valueOf("255.255.255.255");
private static final int TRANSACTION_ID = 1000;
private static final ProviderId PID = new ProviderId("of", "foo");
@Before
public void setUp() {
dhcpManager = new DHCPManager();
dhcpManager.cfgService = new TestNetworkConfigRegistry();
dhcpManager.packetService = new TestPacketService();
dhcpManager.coreService = new TestCoreService();
dhcpManager.dhcpStore = new TestDHCPStore();
hostProviderService = new TestHostProviderService(new TestHostProvider());
dhcpManager.hostProviderService = hostProviderService;
dhcpManager.hostProviderRegistry = new TestHostRegistry();
dhcpManager.activate();
}
@After
public void tearDown() {
dhcpManager.deactivate();
}
/**
* Tests the response to a DHCP Discover Packet.
*/
@Test
public void testDiscover() {
Ethernet reply = constructDHCPPacket(DHCP.DHCPMessageType.MessageType_Discover);
sendPacket(reply);
}
/**
* Tests the response to a DHCP Request Packet.
*/
@Test
public void testRequest() {
Ethernet reply = constructDHCPPacket(DHCP.DHCPMessageType.MessageType_Request);
sendPacket(reply);
}
/**
* Sends an Ethernet packet to the process method of the Packet Processor.
* @param reply Ethernet packet
*/
private void sendPacket(Ethernet reply) {
final ByteBuffer byteBuffer = ByteBuffer.wrap(reply.serialize());
InboundPacket inPacket = new DefaultInboundPacket(connectPoint("1", 1),
reply,
byteBuffer);
PacketContext context = new TestPacketContext(127L, inPacket, null, false);
packetProcessor.process(context);
}
/**
* Constructs an Ethernet packet containing a DHCP Payload.
* @param messageType DHCP Message Type
* @return Ethernet packet
*/
private Ethernet constructDHCPPacket(DHCP.DHCPMessageType messageType) {
// Ethernet Frame.
Ethernet ethReply = new Ethernet();
ethReply.setSourceMACAddress(CLIENT1_MAC);
ethReply.setDestinationMACAddress(MacAddress.BROADCAST);
ethReply.setEtherType(Ethernet.TYPE_IPV4);
ethReply.setVlanID((short) 2);
// IP Packet
IPv4 ipv4Reply = new IPv4();
ipv4Reply.setSourceAddress(0);
ipv4Reply.setDestinationAddress(BROADCAST.toInt());
ipv4Reply.setTtl((byte) 127);
// UDP Datagram.
UDP udpReply = new UDP();
udpReply.setSourcePort((byte) UDP.DHCP_CLIENT_PORT);
udpReply.setDestinationPort((byte) UDP.DHCP_SERVER_PORT);
// DHCP Payload.
DHCP dhcpReply = new DHCP();
dhcpReply.setOpCode(DHCP.OPCODE_REQUEST);
dhcpReply.setYourIPAddress(0);
dhcpReply.setServerIPAddress(0);
dhcpReply.setTransactionId(TRANSACTION_ID);
dhcpReply.setClientHardwareAddress(CLIENT1_MAC.toBytes());
dhcpReply.setHardwareType(DHCP.HWTYPE_ETHERNET);
dhcpReply.setHardwareAddressLength((byte) 6);
// DHCP Options.
DHCPOption option = new DHCPOption();
List<DHCPOption> optionList = new ArrayList<>();
// DHCP Message Type.
option.setCode(DHCP.DHCPOptionCode.OptionCode_MessageType.getValue());
option.setLength((byte) 1);
byte[] optionData = {messageType.getValue()};
option.setData(optionData);
optionList.add(option);
// DHCP Requested IP.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_RequestedIP.getValue());
option.setLength((byte) 4);
optionData = Ip4Address.valueOf(EXPECTED_IP).toOctets();
option.setData(optionData);
optionList.add(option);
// End Option.
option = new DHCPOption();
option.setCode(DHCP.DHCPOptionCode.OptionCode_END.getValue());
option.setLength((byte) 1);
optionList.add(option);
dhcpReply.setOptions(optionList);
udpReply.setPayload(dhcpReply);
ipv4Reply.setPayload(udpReply);
ethReply.setPayload(ipv4Reply);
return ethReply;
}
/**
* Validates the contents of the packet sent by the DHCP Manager.
* @param packet Ethernet packet received
*/
private void validatePacket(Ethernet packet) {
DHCP dhcpPacket = (DHCP) packet.getPayload().getPayload().getPayload();
assertEquals(MacAddress.valueOf(dhcpPacket.getClientHardwareAddress()), CLIENT1_MAC);
assertEquals(Ip4Address.valueOf(dhcpPacket.getYourIPAddress()), Ip4Address.valueOf(EXPECTED_IP));
assertEquals(dhcpPacket.getTransactionId(), TRANSACTION_ID);
}
/**
* Mocks the DHCPStore.
*/
private final class TestDHCPStore implements DHCPStore {
public void populateIPPoolfromRange(Ip4Address startIP, Ip4Address endIP) {
}
public Ip4Address suggestIP(MacAddress macID, Ip4Address requestedIP) {
return Ip4Address.valueOf(EXPECTED_IP);
}
public boolean assignIP(MacAddress macID, Ip4Address ipAddr, int leaseTime) {
return true;
}
public void setDefaultTimeoutForPurge(int timeInSeconds) {
}
public void setTimerDelay(int timeInSeconds) {
}
public void releaseIP(MacAddress macID) {
}
public Map<MacAddress, Ip4Address> listMapping() {
Map<MacAddress, Ip4Address> map = new HashMap<>();
map.put(CLIENT1_MAC, Ip4Address.valueOf(EXPECTED_IP));
return map;
}
public boolean assignStaticIP(MacAddress macID, Ip4Address ipAddr) {
return true;
}
public boolean removeStaticIP(MacAddress macID) {
return true;
}
public Iterable<Ip4Address> getAvailableIPs() {
List<Ip4Address> ipList = new ArrayList<>();
ipList.add(Ip4Address.valueOf(EXPECTED_IP));
return ImmutableSet.copyOf(ipList);
}
}
/**
* Mocks the DefaultPacket context.
*/
private final class TestPacketContext extends DefaultPacketContext {
private TestPacketContext(long time, InboundPacket inPkt,
OutboundPacket outPkt, boolean block) {
super(time, inPkt, outPkt, block);
}
@Override
public void send() {
// We don't send anything out.
}
}
/**
* Keeps a reference to the PacketProcessor and verifies the OutboundPackets.
*/
private class TestPacketService extends PacketServiceAdapter {
@Override
public void addProcessor(PacketProcessor processor, int priority) {
packetProcessor = processor;
}
@Override
public void emit(OutboundPacket packet) {
try {
Ethernet eth = Ethernet.deserializer().deserialize(packet.data().array(),
0, packet.data().array().length);
validatePacket(eth);
} catch (Exception e) {
fail(e.getMessage());
}
}
}
/**
* Mocks the CoreService.
*/
private class TestCoreService extends CoreServiceAdapter {
}
/**
* Mocks the NetworkConfigRegistry.
*/
private class TestNetworkConfigRegistry extends NetworkConfigRegistryAdapter {
}
/**
* Mocks the HostProviderService.
*/
private class TestHostProviderService extends AbstractProviderService<HostProvider>
implements HostProviderService {
protected TestHostProviderService(HostProvider provider) {
super(provider);
}
@Override
public void hostDetected(HostId hostId, HostDescription hostDescription) {
}
@Override
public void hostVanished(HostId hostId) {
}
}
/**
* Mocks the HostProvider.
*/
private static class TestHostProvider extends AbstractProvider
implements HostProvider {
protected TestHostProvider() {
super(PID);
}
@Override
public ProviderId id() {
return PID;
}
@Override
public void triggerProbe(Host host) {
}
}
/**
* Mocks the HostProviderRegistry.
*/
private class TestHostRegistry implements HostProviderRegistry {
@Override
public HostProviderService register(HostProvider provider) {
return hostProviderService;
}
@Override
public void unregister(HostProvider provider) {
}
@Override
public Set<ProviderId> getProviders() {
return null;
}
}
}
{
"apps": {
"org.onosproject.dhcp" : {
"dhcp" : {
"ip": "10.0.0.1",
"mac": "1a:2b:3c:4e:5e:6f",
"subnet": "255.0.0.0",
"broadcast": "10.255.255.255",
"router": "10.0.0.1",
"domain": "10.0.0.1",
"ttl": "63",
"lease": "300",
"renew": "150",
"rebind": "200"
},
"dhcpstore" : {
"delay": "3",
"timeout": "150",
"startip": "10.0.0.110",
"endip": "10.0.0.130"
}
}
}
}
\ No newline at end of file
......@@ -57,6 +57,7 @@
<module>vtnrsc</module>
<module>vtn</module>
<module>vtnweb</module>
<module>onos-app-dhcp</module>
</modules>
<properties>
......