홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
Naoki Shiota
Committed by Yuta HIGUCHI
5a05606a 1 parent dbb631fc

Moved ecord.metro app to onos repo. (ONOS-4441) 

Change-Id: I9a5d2935012eee433a4f63c672c16bdcb8d6b6b8
Expand all
Inline Side-by-side
Showing 18 changed files with 913 additions and 0 deletions
......@@ -122,6 +122,7 @@ APPS = [
'//apps/openstacknetworking/openstackswitching:onos-apps-openstacknetworking-openstackswitching-oar',
'//apps/mobility:onos-apps-mobility-oar',
'//apps/optical:onos-apps-optical-oar',
'//apps/newoptical:onos-apps-newoptical-oar',
'//apps/pathpainter:onos-apps-pathpainter-oar',
'//apps/pcep-api:onos-apps-pcep-api-oar',
'//apps/pim:onos-apps-pim-oar',
......
COMPILE_DEPS = [
'//lib:CORE_DEPS',
'//lib:org.apache.karaf.shell.console',
'//cli:onos-cli',
]
osgi_jar_with_tests (
deps = COMPILE_DEPS,
)
onos_app (
title = 'Packet/Optical Use-Case App',
category = 'Traffic Steering',
url = 'http://onosproject.org',
description = 'Packet/Optical use-case application.',
)
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ Copyright 2016 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.6.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<artifactId>onos-app-newoptical</artifactId>
<packaging>bundle</packaging>
<description>Application for setup optical network</description>
<url>http://onosproject.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<onos.app.name>org.onosproject.newoptical</onos.app.name>
<onos.app.category>Traffic Steering</onos.app.category>
<onos.app.url>http://onosproject.org</onos.app.url>
<onos.app.origin>Open Networking Lab</onos.app.origin>
</properties>
<dependencies>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-api</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-core-dist</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-api</artifactId>
<version>${project.version}</version>
<scope>test</scope>
<classifier>tests</classifier>
</dependency>
<dependency>
<groupId>org.apache.felix</groupId>
<artifactId>org.apache.felix.scr.annotations</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.compendium</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.karaf.shell</groupId>
<artifactId>org.apache.karaf.shell.console</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-cli</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.karaf.tooling</groupId>
<artifactId>karaf-maven-plugin</artifactId>
<extensions>true</extensions>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
<extensions>true</extensions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-scr-plugin</artifactId>
<executions>
<execution>
<id>generate-scr-srcdescriptor</id>
<goals>
<goal>scr</goal>
</goals>
</execution>
</executions>
<configuration>
<supportedProjectTypes>
<supportedProjectType>bundle</supportedProjectType>
<supportedProjectType>war</supportedProjectType>
</supportedProjectTypes>
</configuration>
</plugin>
<plugin>
<groupId>org.onosproject</groupId>
<artifactId>onos-maven-plugin</artifactId>
<executions>
<execution>
<id>cfg</id>
<phase>generate-resources</phase>
<goals>
<goal>cfg</goal>
</goals>
</execution>
<execution>
<id>swagger</id>
<phase>generate-sources</phase>
<goals>
<goal>swagger</goal>
</goals>
</execution>
<execution>
<id>app</id>
<phase>package</phase>
<goals>
<goal>app</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
/*
* Copyright 2016 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.newoptical;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.onlab.util.Bandwidth;
import org.onosproject.newoptical.api.OpticalConnectivityId;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.Link;
import org.onosproject.net.Path;
import org.onosproject.net.intent.IntentId;
import java.time.Duration;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Entity to store optical connectivity request and related information.
*/
@Beta
public class OpticalConnectivity {
private final OpticalConnectivityId id;
private final List<Link> links;
private final Bandwidth requestBandwidth;
private final Duration requestLatency;
// Bandwidth capacity of optical layer
private Bandwidth opticalCapacity;
private final Set<PacketLinkRealizedByOptical> realizingLinks = new HashSet<>();
// TODO: This IntentId is used only to reserve bandwidth resource.
// After ResourceManager is made to accept app-defined ResourceConsumer,
// this Intent should be replaced with OpticalConnectivityId.
private IntentId intentId;
private State state = State.CREATED;
public enum State {
CREATED,
INSTALLING,
INSTALLED,
WITHDRAWING,
WITHDRAWN,
FAILED
}
public OpticalConnectivity(OpticalConnectivityId id, Path path, Bandwidth requestBandwidth,
Duration requestLatency) {
this.id = id;
this.links = ImmutableList.copyOf(path.links());
this.requestBandwidth = requestBandwidth;
this.requestLatency = requestLatency;
}
public void setLinkEstablished(ConnectPoint src, ConnectPoint dst) {
realizingLinks.stream().filter(l -> l.isBetween(src, dst))
.findAny()
.ifPresent(l -> l.setEstablished(true));
}
public void setLinkRemoved(ConnectPoint src, ConnectPoint dst) {
realizingLinks.stream().filter(l -> l.isBetween(src, dst))
.findAny()
.ifPresent(l -> l.setEstablished(false));
}
public boolean isAllRealizingLinkEstablished() {
return realizingLinks.stream().allMatch(PacketLinkRealizedByOptical::isEstablished);
}
public boolean isAllRealizingLinkNotEstablished() {
return !realizingLinks.stream().anyMatch(PacketLinkRealizedByOptical::isEstablished);
}
public OpticalConnectivityId id() {
return id;
}
public List<Link> links() {
return links;
}
public Bandwidth bandwidth() {
return requestBandwidth;
}
public Duration latency() {
return requestLatency;
}
public State state() {
return state;
}
public boolean state(State state) {
boolean valid = true;
// reject invalid state transition
switch (this.state) {
case CREATED:
valid = (state == State.INSTALLING || state == State.FAILED);
break;
case INSTALLING:
valid = (state == State.INSTALLED || state == State.FAILED);
break;
case INSTALLED:
valid = (state == State.WITHDRAWING || state == State.FAILED);
break;
case WITHDRAWING:
valid = (state == State.WITHDRAWN || state == State.FAILED);
break;
case FAILED:
valid = (state == State.INSTALLING || state == State.WITHDRAWING || state == State.FAILED);
break;
default:
break;
}
if (valid) {
this.state = state;
}
return valid;
}
public Bandwidth getOpticalCapacity() {
return opticalCapacity;
}
public void setOpticalCapacity(Bandwidth opticalCapacity) {
this.opticalCapacity = opticalCapacity;
}
public void addRealizingLink(PacketLinkRealizedByOptical link) {
checkNotNull(link);
realizingLinks.add(link);
}
public void removeRealizingLink(PacketLinkRealizedByOptical link) {
checkNotNull(link);
realizingLinks.remove(link);
}
public Set<PacketLinkRealizedByOptical> getRealizingLinks() {
return ImmutableSet.copyOf(realizingLinks);
}
public IntentId getIntentId() {
return intentId;
}
public void setIntentId(IntentId intentId) {
this.intentId = intentId;
}
}
/*
* Copyright 2016 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.newoptical;
import com.google.common.annotations.Beta;
import org.onlab.util.Bandwidth;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.intent.Key;
import org.onosproject.net.intent.OpticalCircuitIntent;
import org.onosproject.net.intent.OpticalConnectivityIntent;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Entity to represent packet link realized by optical intent.
*/
@Beta
public class PacketLinkRealizedByOptical {
private final ConnectPoint src, dst;
private final Bandwidth bandwidth;
// TODO should be list of Intent Key?
private final Key realizingIntentKey;
// established=false represents that this (packet) link is expected to be
// discovered after underlying (optical) path has been provisioned.
private boolean established;
/**
* Creates instance with specified parameters.
*
* @param src source connect point
* @param dst destination connect point
* @param realizingIntentKey key of Optical*Intent that realizes packet link between src and dst
* @param bandwidth assigned bandwidth
*/
public PacketLinkRealizedByOptical(ConnectPoint src, ConnectPoint dst,
Key realizingIntentKey, Bandwidth bandwidth) {
this.src = src;
this.dst = dst;
this.realizingIntentKey = realizingIntentKey;
this.bandwidth = bandwidth;
this.established = false;
}
/**
* Creates PacketLinkRealizedByOptical instance with specified connect points and OpticalCircuitIntent.
* Assigned bandwidth is taken from physical limit of optical link.
*
* @param src source connect point
* @param dst destination connect point
* @param intent OpticalCircuitIntent that realizes packet link between src and dst
* @return
*/
public static PacketLinkRealizedByOptical create(ConnectPoint src, ConnectPoint dst,
OpticalCircuitIntent intent) {
checkNotNull(src);
checkNotNull(dst);
checkNotNull(intent);
long rate = intent.getSignalType().bitRate();
return new PacketLinkRealizedByOptical(src, dst, intent.key(), Bandwidth.bps(rate));
}
/**
* Creates PacketLinkRealizedByOptical instance with specified connect points and OpticalConnectivityIntent.
* Assigned bandwidth is taken from physical limit of optical link.
*
* @param src source connect point
* @param dst destination connect point
* @param intent OpticalConnectivityIntent that realizes packet link between src and dst
* @return
*/
public static PacketLinkRealizedByOptical create(ConnectPoint src, ConnectPoint dst,
OpticalConnectivityIntent intent) {
checkNotNull(src);
checkNotNull(dst);
checkNotNull(intent);
long rate = intent.getSignalType().bitRate();
return new PacketLinkRealizedByOptical(src, dst, intent.key(), Bandwidth.bps(rate));
}
/**
* Returns source connect point.
*
* @return source connect point
*/
public ConnectPoint src() {
return src;
}
/**
* Returns destination connect point.
*
* @return destination connect point
*/
public ConnectPoint dst() {
return dst;
}
/**
* Returns assigned bandwidth.
*
* @return assigned bandwidth
*/
public Bandwidth bandwidth() {
return bandwidth;
}
/**
* Returns intent key.
*
* @return intent key
*/
public Key realizingIntentKey() {
return realizingIntentKey;
}
/**
* Returns whether packet link is realized or not.
*
* @return true if packet link is realized. false if not.
*/
public boolean isEstablished() {
return established;
}
/**
* Sets packet link to be established.
*
* @param established status of packet link
*/
public void setEstablished(boolean established) {
this.established = established;
}
/**
* Check if packet link is between specified two connect points.
*
* @param src source connect point
* @param dst destination connect point
* @return true if this link is between src and dst. false if not.
*/
public boolean isBetween(ConnectPoint src, ConnectPoint dst) {
return (this.src.equals(src) && this.dst.equals(dst));
}
}
/*
* Copyright 2016 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.newoptical.api;
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import org.onlab.util.Identifier;
// TODO: After ResourceManager is made to accept app-defined ResourceConsumer,
// this class should be implemented as ResourceConsumer.
/**
* ID for optical connectivity.
*/
@Beta
public final class OpticalConnectivityId extends Identifier<Long> {
public static OpticalConnectivityId of(long value) {
return new OpticalConnectivityId(value);
}
OpticalConnectivityId(long value) {
super(value);
}
@Override
public String toString() {
return MoreObjects.toStringHelper(this)
.add("value", id())
.toString();
}
}
/*
* Copyright 2016 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.newoptical.api;
import com.google.common.annotations.Beta;
import org.onosproject.event.AbstractEvent;
/**
* Event related to optical domain path setup.
*/
@Beta
public class OpticalPathEvent extends AbstractEvent<OpticalPathEvent.Type, OpticalConnectivityId> {
public enum Type {
PATH_INSTALLED,
PATH_REMOVED
}
/**
* Creates OpticalPathEvent object with specified type and subject.
* @param type
* @param subject
*/
public OpticalPathEvent(Type type, OpticalConnectivityId subject) {
super(type, subject);
}
}
/*
* Copyright 2016 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.newoptical.api;
import org.onosproject.event.EventListener;
/**
* Entity capable of receiving optical path related events.
*/
public interface OpticalPathListener extends EventListener<OpticalPathEvent> {
}
/*
* Copyright 2016 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.newoptical.api;
import com.google.common.annotations.Beta;
import org.onlab.util.Bandwidth;
import org.onosproject.event.ListenerService;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.Link;
import org.onosproject.net.Path;
import java.time.Duration;
import java.util.List;
/**
* Service to setup optical domain connectivity.
*/
@Beta
public interface OpticalPathService extends ListenerService<OpticalPathEvent, OpticalPathListener> {
/**
* Calculates optical path between connect points and sets up connectivity.
*
* @param ingress ingress port
* @param egress egress port
* @param bandwidth required bandwidth. No bandwidth is assured if null.
* @param latency required latency. No latency is assured if null.
* @return ID of created connectivity if successful. null otherwise.
*/
OpticalConnectivityId setupConnectivity(ConnectPoint ingress, ConnectPoint egress,
Bandwidth bandwidth, Duration latency);
/**
* Sets up connectivity along given optical path.
*
* @param path path along which connectivity will be set up
* @param bandwidth required bandwidth. No bandwidth is assured if null.
* @param latency required latency. No latency is assured if null.
* @return true if successful. false otherwise.
*/
OpticalConnectivityId setupPath(Path path, Bandwidth bandwidth, Duration latency);
/**
* Removes connectivity with given ID.
*
* @param id ID of connectivity
* @return true if succeed. false if failed.
*/
boolean removeConnectivity(OpticalConnectivityId id);
/**
* Returns path assigned to given ID.
* @param id ID of connectivity
* @return list of link that compose a path. null if ID is invalid.
*/
List<Link> getPath(OpticalConnectivityId id);
}
/*
* Copyright 2016 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.
*/
/**
* API to optical path service.
*/
package org.onosproject.newoptical.api;
\ No newline at end of file
/*
* Copyright 2016 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.newoptical.cli;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onlab.util.Bandwidth;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.newoptical.api.OpticalConnectivityId;
import org.onosproject.newoptical.api.OpticalPathService;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.DeviceId;
import org.onosproject.net.PortNumber;
@Command(scope = "onos", name = "add-optical-connectivity",
description = "Configure optical domain connectivity")
public class AddOpticalConnectivityCommand extends AbstractShellCommand {
@Argument(index = 0, name = "ingress", description = "Ingress connect point",
required = true, multiValued = false)
String ingressStr = null;
@Argument(index = 1, name = "egress", description = "Egress connect point",
required = true, multiValued = false)
String egressStr = null;
@Argument(index = 2, name = "bandwidth", description = "Bandwidth",
required = false, multiValued = false)
String bandwidthStr = null;
@Argument(index = 3, name = "latency", description = "Latency",
required = true, multiValued = false)
String latencyStr = null;
@Override
protected void execute() {
OpticalPathService opticalPathService = get(OpticalPathService.class);
ConnectPoint ingress = readConnectPoint(ingressStr);
ConnectPoint egress = readConnectPoint(egressStr);
if (ingress == null || egress == null) {
print("Invalid connect points: %s, %s", ingressStr, egressStr);
return;
}
Bandwidth bandwidth = (bandwidthStr == null || bandwidthStr.isEmpty()) ? null :
Bandwidth.bps(Long.valueOf(bandwidthStr));
print("Trying to setup connectivity between %s and %s.", ingress, egress);
OpticalConnectivityId id = opticalPathService.setupConnectivity(ingress, egress, bandwidth, null);
if (id == null) {
print("Failed.");
return;
}
print("Optical path ID : %s", id.id());
}
private ConnectPoint readConnectPoint(String str) {
String[] strings = str.split("/");
if (strings.length != 2) {
return null;
}
DeviceId devId = DeviceId.deviceId(strings[0]);
PortNumber port = PortNumber.portNumber(strings[1]);
return new ConnectPoint(devId, port);
}
}
/*
* Copyright 2016 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.newoptical.cli;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.newoptical.api.OpticalConnectivityId;
import org.onosproject.newoptical.api.OpticalPathService;
@Command(scope = "onos", name = "remove-optical-connectivity",
description = "Remove optical domain connectivity")
public class RemoveOpticalConnectivityCommand extends AbstractShellCommand {
@Argument(index = 0, name = "id", description = "ID of optical connectivity",
required = true, multiValued = false)
String idStr = null;
@Override
protected void execute() {
OpticalPathService opticalPathService = get(OpticalPathService.class);
OpticalConnectivityId id = OpticalConnectivityId.of(Long.valueOf(idStr));
print("Trying to remove connectivity with id %s.", idStr);
if (opticalPathService.removeConnectivity(id)) {
print(" -- success");
} else {
print(" -- failed");
}
}
}
/*
* Copyright 2016 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.
*/
/**
* CLI to control optical path service.
*/
package org.onosproject.newoptical.cli;
\ No newline at end of file
/*
* Copyright 2016 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.
*/
/**
* Module to control optical path.
*/
package org.onosproject.newoptical;
\ No newline at end of file
<!--
~ Copyright 2016 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.newoptical.cli.AddOpticalConnectivityCommand"/>
</command>
<command>
<action class="org.onosproject.newoptical.cli.RemoveOpticalConnectivityCommand"/>
</command>
</command-bundle>
</blueprint>
......@@ -66,8 +66,11 @@ import static org.onosproject.net.optical.device.OpticalDeviceServiceView.optica
* OpticalPathProvisioner listens for event notifications from the Intent F/W.
* It generates one or more opticalConnectivityIntent(s) and submits (or withdraws) to Intent F/W
* for adding/releasing capacity at the packet layer.
*
* @deprecated in Goldeneye (1.6.0)
*/
@Deprecated
@Component(immediate = true)
public class OpticalPathProvisioner {
......
......@@ -37,6 +37,7 @@
<module>proxyarp</module>
<module>sdnip</module>
<module>optical</module>
<module>newoptical</module>
<module>metrics</module>
<module>routing</module>
<module>routing-api</module>
......