JDK8 has stricter javadoc rules, make sure we do not fail on them.
Change-Id: I13ae2d0cc750faf66dc4f0c41a7982f9e9aae4cb
Signed-off-by: Robert Varga <rovarga@cisco.com>
void flowNodeConnected(InstanceIdentifier<FlowCapableNode> connectedNode);
/**
- * Method contains functionality for registered Node {@FlowCapableNode} removing
- * from {@Link ForwardingRulesManager}
+ * Method contains functionality for registered Node {@link FlowCapableNode} removing
+ * from {@link ForwardingRulesManager}
*
* @param disconnectedNode - {@link org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier} to removed Node
*/
* Method removes DataObject which is identified by InstanceIdentifier
* from device.
*
- * @param InstanceIdentifier identifier - the whole path to DataObject
- * @param DataObject remove - DataObject for removing
- * @param InstanceIdentifier<FlowCapableNode> parent Node InstanceIdentifier
+ * @param identifier - the whole path to DataObject
+ * @param del - DataObject for removing
+ * @param nodeIdent Node InstanceIdentifier
*/
void remove(InstanceIdentifier<D> identifier, D del,
InstanceIdentifier<FlowCapableNode> nodeIdent);
* Method updates the original DataObject to the update DataObject
* in device. Both are identified by same InstanceIdentifier
*
- * @param InstanceIdentifier identifier - the whole path to DataObject
- * @param DataObject original - original DataObject (for update)
- * @param DataObject update - changed DataObject (contain updates)
+ * @param identifier - the whole path to DataObject
+ * @param original - original DataObject (for update)
+ * @param update - changed DataObject (contain updates)
+ * @param nodeIdent Node InstanceIdentifier
*/
void update(InstanceIdentifier<D> identifier, D original, D update,
InstanceIdentifier<FlowCapableNode> nodeIdent);
* Method adds the DataObject which is identified by InstanceIdentifier
* to device.
*
- * @param InstanceIdentifier identifier - the whole path to new DataObject
- * @param DataObject add - new DataObject
+ * @param identifier - the whole path to new DataObject
+ * @param add - new DataObject
+ * @param nodeIdent Node InstanceIdentifier
*/
void add(InstanceIdentifier<D> identifier, D add,
InstanceIdentifier<FlowCapableNode> nodeIdent);
* Method returns information :
* "is Node with send InstanceIdentifier connected"?
*
- * @param InstanceIdentifier<FlowCapableNode> ident - the key of the node
- * @return boolean - is device connected
+ * @param ident - the key of the node
+ * @return boolean - true if device is connected
*/
public boolean isNodeActive(InstanceIdentifier<FlowCapableNode> ident);
* ActiveNodeHolder prevent unnecessary Operational/DS read for identify
* pre-configure and serious Configure/DS transactions.
*
- * @param InstanceIdentifier<FlowCapableNode> ident - the key of the node
+ * @param ident - the key of the node
*/
public void registrateNewNode(InstanceIdentifier<FlowCapableNode> ident);
* Holder. And all next flows or groups or meters will stay in Config/DS
* only.
*
- * @param InstanceIdentifier<FlowCapableNode> ident - the key of the node
+ * @param ident - the key of the node
*/
public void unregistrateNode(InstanceIdentifier<FlowCapableNode> ident);
/**
* Content definition method and prevent code duplicity in Reconcil
- * @return ForwardingRulesCommiter<Flow>
+ * @return ForwardingRulesCommiter<Flow>
*/
public ForwardingRulesCommiter<Flow> getFlowCommiter();
/**
* Content definition method and prevent code duplicity in Reconcil
- * @return ForwardingRulesCommiter<Group>
+ * @return ForwardingRulesCommiter<Group>
*/
public ForwardingRulesCommiter<Group> getGroupCommiter();
/**
* Content definition method and prevent code duplicity
- * @return ForwardingRulesCommiter<Meter>
+ * @return ForwardingRulesCommiter<Meter>
*/
public ForwardingRulesCommiter<Meter> getMeterCommiter();
* as a prevention to use a validation check to the Operational/DS for identify
* connected {@link org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode}.
*
- * @param InstanceIdentifier<SwitchFeatures> keyIdent
- * @param FlowCapableNode data
- * @param InstanceIdentifier<Node> nodeIdent
+ * @param keyIdent
+ * @param data
+ * @param nodeIdent
*/
void connectFlowCapableNode(InstanceIdentifier<SwitchFeatures> keyIdent,
SwitchFeatures data, InstanceIdentifier<Node> nodeIdent);
/**
* Method cut {@link Node} registration for {@link StatPermCollector}
*
- * @param InstanceIdentifier<Node> keyIdent
+ * @param keyIdent
*/
void disconnectFlowCapableNode(InstanceIdentifier<Node> keyIdent);
}
/**
* Add new connected node for permanent statistics collecting process
*
- * @param flowNode
+ * @param nodeIdent
* @param statTypes
* @param nrOfSwitchTables
* @return true/false if the {@link Node} added successful
/**
* All disconnected Nodes need be removed from stat list Nodes
*
- * @param flowNode
+ * @param nodeIdent
* @return true/false if the {@link Node} removed successful
*/
boolean disconnectedNodeUnregistration(InstanceIdentifier<Node> nodeIdent);
/**
* Method add new feature {@link StatCapabTypes} to Node identified by
- * nodeIdent -> InstanceIdentifier<Node>
+ * nodeIdent -> InstanceIdentifier<Node>
*
- * @param flowNode
+ * @param nodeIdent
* @return true/false if the {@link StatCapabTypes} add successful
*/
boolean registerAdditionalNodeFeature(InstanceIdentifier<Node> nodeIdent, StatCapabTypes statCapab);
* valid node registration in its internal {@link Node} map.
* Otherwise return false.
*
- * @param flowNode
+ * @param nodeIdent
* @return
*/
boolean isProvidedFlowNodeActive(InstanceIdentifier<Node> nodeIdent);
* Transaction container is definition for Multipart transaction
* join container for all Multipart msg with same TransactionId
* Input {@link DataObject} is a possible light-weight DataObject
- * which is used for identification (e.g. Flow-> Priority,Match,Cookie,FlowId)
+ * which is used for identification (e.g. Flow -> Priority,Match,Cookie,FlowId)
*
- * @param <T> extends TransactionAware -
+ * @param <T>
*/
interface TransactionCacheContainer<T extends TransactionAware> {
* Method is used for check a transaction registration
* for multipart cache holder
*
- * @param TransactionId id
+ * @param id
* @return true if the transaction has been correctly registered
*/
Future<Boolean> isExpectedStatistics(TransactionId id, NodeId nodeId);
* and build all to TransactionCacheContainer Object to return. This process clean
* all instances in Cache.
*
- * @param TransactionId id
+ * @param id
* @return TransactionCacheContainer
*/
Future<Optional<TransactionCacheContainer<?>>> getTransactionCacheContainer(TransactionId id, NodeId nodeId);
* Method wraps OpendaylightGroupStatisticsService.getAllGroupStatistics
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
Future<TransactionId> getAllGroupsStat(NodeRef nodeRef);
* Method wraps OpendaylightGroupStatisticsService.getGroupDescription
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
Future<TransactionId> getAllGroupsConfStats(NodeRef nodeRef);
* Method wraps OpendaylightMeterStatisticsService.getGroupFeatures
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
void getGroupFeaturesStat(NodeRef nodeRef);
* Method wraps OpendaylightMeterStatisticsService.getAllMeterStatistics
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
Future<TransactionId> getAllMetersStat(NodeRef nodeRef);
* Method wraps OpendaylightMeterStatisticsService.getAllMeterConfigStatistics
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
Future<TransactionId> getAllMeterConfigStat(NodeRef nodeRef);
* Method wraps OpendaylightMeterStatisticsService.getMeterFeatures
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
void getMeterFeaturesStat(NodeRef nodeRef);
* Method wraps OpendaylightFlowStatisticsService.getAllFlowsStatisticsFromAllFlowTables
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
Future<TransactionId> getAllFlowsStat(NodeRef nodeRef);
* Method wraps OpendaylightFlowStatisticsService.getAggregateFlowStatisticsFromFlowTableForAllFlows
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
- * @param TableId tableId
+ * @param nodeRef
+ * @param tableId
*/
void getAggregateFlowStat(NodeRef nodeRef, TableId tableId);
* Method wraps OpendaylightPortStatisticsService.getAllNodeConnectorsStatistics
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
Future<TransactionId> getAllPortsStat(NodeRef nodeRef);
* Method wraps OpendaylightFlowTableStatisticsService.getFlowTablesStatistics
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
Future<TransactionId> getAllTablesStat(NodeRef nodeRef);
* Method wraps OpendaylightQueueStatisticsService.getAllQueuesStatisticsFromAllPorts
* and registers to Transaction Cache
*
- * @param NodeRef nodeRef
+ * @param nodeRef
*/
Future<TransactionId> getAllQueueStat(NodeRef nodeRef);
* StatisticsManager
* It represent a central point for whole module. Implementation
* StatisticsManager registers all Operation/DS {@link StatNotifyCommiter} and
- * Config/DS {@StatListeningCommiter}, as well as {@link StatPermCollector}
+ * Config/DS {@link StatListeningCommiter}, as well as {@link StatPermCollector}
* for statistic collecting and {@link StatRpcMsgManager} as Device RPCs provider.
* In next, StatisticsManager provides all DS contact Transaction services.
*
/**
* Apply all read / write (put|merge) operation for DataStore
*
- * @param {@link ReadWriteTransaction} tx
+ * @param tx {@link ReadWriteTransaction}
*/
public abstract void applyOperation(ReadWriteTransaction tx);
/**
* Method starts whole StatisticManager functionality
*
- * @param {@link NotificationProviderService} notifService
- * @param {@link RpcConsumerRegistry} rpcRegistry
- * @param minReqNetMonitInt
+ * @param notifService
+ * @param rpcRegistry
*/
void start(final NotificationProviderService notifService,
final RpcConsumerRegistry rpcRegistry);
void enqueue(final StatDataStoreOperation inventoryOper);
/**
- * Method wraps {@link StatisticCollector}.isProvidedFlowNodeActive method
+ * Method wraps {@link StatisticsManager#isProvidedFlowNodeActive(InstanceIdentifier)} method
* to provide parallel statCollection process for Set of Nodes. So it has to
* identify correct Node Set by NodeIdentifier
*
/**
* Define Method : {@link org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode}
- * Operational/DS data change listener -> impl. target -> register FlowCapableNode to Statistic Collecting process
+ * Operational/DS data change listener -> impl. target -> register FlowCapableNode to Statistic Collecting process
* @return {@link StatNodeRegistration}
*/
StatNodeRegistration getNodeRegistrator();
/**
- * Define Method : Flow Config/DS data change listener -> impl. target ->
- * -> make pair between Config/DS FlowId and Device Flow response Hash
+ * Define Method : Flow Config/DS data change listener -> impl. target ->
+ * -> make pair between Config/DS FlowId and Device Flow response Hash
* @return
*/
StatListeningCommiter<Flow, OpendaylightFlowStatisticsListener> getFlowListenComit();
public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changeEvent) {
Preconditions.checkNotNull(changeEvent,"Async ChangeEvent can not be null!");
/*
- * If we have opened read transaction for configuraiton data store,
+ * If we have opened read transaction for configuration data store,
* we will close and null it.
*
* Latest read transaction will be allocated on another read using readLatestConfiguration
protected abstract N getStatNotificationListener();
/**
- * PreConfigurationCheck - Node identified by input InstanceIdentifier<Node>
+ * PreConfigurationCheck - Node identified by input InstanceIdentifier<Node>
* has to be registered in {@link org.opendaylight.openflowplugin.applications.statistics.manager.StatPermCollector}
*
- * @param InstanceIdentifier<Node> nodeIdent
+ * @param nodeIdent
*/
protected boolean preConfigurationCheck(final InstanceIdentifier<Node> nodeIdent) {
Preconditions.checkNotNull(nodeIdent, "FlowCapableNode ident can not be null!");
* getTransactionCacheContainer with 10sec TimeOut.
* Method has returned {@link Optional} which could contains a {@link TransactionCacheContainer}
*
- * @param TransactionId transId
- * @param NodeId nodeId
+ * @param transId
+ * @param nodeId
* @return
*/
protected Optional<TransactionCacheContainer<?>> getTransactionCacheContainer(final TransactionId transId, final NodeId nodeId) {
* isExpectedStatistics with 10sec TimeOut.
* Method has checked registration for provided {@link TransactionId} and {@link NodeId}
*
- * @param TransactionId transId - Transaction identification
- * @param NodeId nodeId - Node identification
+ * @param transId - Transaction identification
+ * @param nodeId - Node identification
* @return boolean
*/
protected boolean isExpectedStatistics(final TransactionId transId, final NodeId nodeId) {
* StatisticsManagerImpl
* It represent a central point for whole module. Implementation
* {@link StatisticsManager} registers all Operation/DS {@link StatNotifyCommiter} and
-* Config/DS {@StatListeningCommiter}, as well as {@link StatPermCollector}
+* Config/DS {@link StatListeningCommiter}, as well as {@link StatPermCollector}
* for statistic collecting and {@link StatRpcMsgManager} as Device RPCs provider.
* In next, StatisticsManager provides all DS contact Transaction services.
*
private final NiciraExtensionCodecRegistrator registrator;
/**
- * @param providers cannot be null
+ * @param registrator cannot be null
*/
public NiciraExtensionsRegistrator(NiciraExtensionCodecRegistrator registrator) {
- Preconditions.checkNotNull(registrator);
- this.registrator = registrator;
+ this.registrator = Preconditions.checkNotNull(registrator);
}
public void registerNiciraExtensions() {
/**
* Provides augmentation resolving upon given {@link Augmentable}.
* Used {@link Augmentation}s do not share {@link Augmentable}.
- * <br/>
+ * <br>
* <b>Usage:</b> in case there are multiple {@link Augmentable} classes which might contain
* corresponding {@link Augmentation}s (1:1..n binding). And those {@link Augmentation}s
* are sharing the same grouping so that they could be processed in the same way.
/**
* @param commonInterface
- * @param common grouping Interface
*/
public GroupingLooseResolver(Class<G> commonInterface) {
this.commonInterface = commonInterface;
/**
* Provides augmentation resolving upon given {@link Augmentable}.
* Used {@link #classes} share the same {@link Augmentable}.
- * <br/>
+ * <br>
* <b>Usage:</b> in case there is {@link Augmentable} which might contain
* multiple {@link Augmentation}s depending on origin. And those {@link Augmentation}s
* are sharing the same grouping so that they could be processed in the same way.
}
return Optional.absent();
}
-}
\ No newline at end of file
+}
<F extends Action, T extends DataContainer> ConvertorActionToOFJava<F, T> getConverter(TypeVersionKey<F> key);
/**
- * lookup converter<br/>
+ * lookup converter<br>
* TODO: this method should be compatible with {@link #getConverter(MessageTypeKey)} after matches are migrated to similar structure
* @param key
* @return found converter
*/
NODES_NODE_TABLE_FLOW_INSTRUCTIONS_INSTRUCTION_WRITEACTIONSCASE_WRITEACTIONS_ACTION_ACTION_EXTENSIONLIST_EXTENSION(null),
/**
+ * openflowplugin-extension-general.yang
+ * <pre>
* module: opendaylight-inventory
* +--rw nodes
* +--rw node* [id]
*/
FLOWSSTATISTICSUPDATE_FLOWANDSTATISTICSMAPLIST_INSTRUCTIONS_INSTRUCTION_INSTRUCTION_WRITEACTIONSCASE_WRITEACTIONS_ACTION_ACTION(null),
/**
+ * openflowplugin-extension-general.yang
+ * <pre>
* module: opendaylight-flow-statistics
* notifications:
* +---n flows-statistics-update
}
/**
- * @param openflow nodeConnector uri
+ * @param uri openflow nodeConnector URI
* @param node
* @return assembled nodeConnector
*/
import java.util.Collection;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 27.3.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 27.3.2015.
*/
public interface OpenFlowPluginProvider extends AutoCloseable {
/**
* Each OpenFlow session is tracked by a Connection Context. These attach to a particular Device Context in such a way,
* that there is at most one primary session associated with a Device Context.
- * <p/>
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
+ * <p>
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public interface ConnectionContext extends MultiMsgCollector {
* Connection manager manages connections with devices.
* It instantiates and registers {@link ConnectionContext}
* used for handling all communication with device when onSwitchConnected notification is processed.
- * <p/>
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
+ * <p>
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public interface ConnectionManager extends SwitchConnectionHandler {
* which is enforced by keeping a cap on the number of outstanding requests a particular Request
* Context can have at any point in time. Should this quota be exceeded, any further attempt to make
* a request to the switch will fail immediately, with proper error indication.
- * <p/>
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
+ * <p>
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public interface DeviceContext extends MessageHandler {
* This interface is responsible for instantiating DeviceContext and
* registering transaction chain for each DeviceContext. Each device
* has its own device context managed by this manager.
- * <p/>
- * <p/>
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
+ * <p>
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public interface DeviceManager extends DeviceConnectedHandler {
import java.util.Set;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public interface DeviceState {
/**
* Request context handles all requests on device. Number of requests is limited by request quota. When this quota is
* exceeded all rpc's will end up with exception.
- * <p/>
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
+ * <p>
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public interface RequestContext<T extends DataObject> extends RequestFutureContext<T>, AutoCloseable {
import org.opendaylight.yangtools.yang.common.RpcResult;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 25.3.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.3.2015.
+ * @param <T>
*/
public interface RequestFutureContext<T extends DataObject> {
/**
* Method returns future to be used for handling device requests.
*
- * @param <T>
* @return
*/
SettableFuture<RpcResult<T>> getFuture();
-
}
package org.opendaylight.openflowplugin.api.openflow.device;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 26.2.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 26.2.2015.
*/
public class Xid {
import java.util.concurrent.atomic.AtomicLong;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 24.3.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 24.3.2015.
*/
public class XidGenerator {
package org.opendaylight.openflowplugin.api.openflow.device.exception;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public class RequestQuotaExceededException extends Exception {
}
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 26.2.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 26.2.2015.
*/
public interface DeviceConnectedHandler {
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 27.2.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 27.2.2015.
*/
public interface DeviceContextReadyHandler {
/**
* This handler does the same, but is not called in the same time as
* RequestContextReadyHandler.
*
- * Created by Martin Bobak <mbobak@cisco.com> on 27.2.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 27.2.2015.
*/
public interface DeviceSynchronizedHandler extends DeviceContextReadyHandler {
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 26.2.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 26.2.2015.
*/
public interface MessageHandler {
List<Short> versionOrder = Lists.newArrayList((short) 0x04, (short) 0x01);
/**
- * initialize wiring around {@link #connectionAdapter}
+ * initialize wiring around {@link ConnectionAdapter}
*/
void init();
* This processing mechanism based on queue. Processing consists of 2 steps: translate and publish.
* Proposed workflow (might slightly deviate in implementations):
* <ol>
- * <li>messages of input type are pushed in (via {@link QueueKeeper#push(Object, ConnectionConductor)} and similar)</li>
+ * <li>messages of input type are pushed in (via {@link QueueKeeper#push(Object, ConnectionConductor, QueueType)} and similar)</li>
* <li>ticket (executable task) is build upon each pushed message and enqueued</li>
* <li>ticket is translated using appropriate translator</li>
* <li>ticket is dequeued and result is published by appropriate popListener</li>
* </ol>
* Message order might be not important, e.g. when speed is of the essence
* @param <I> source type (IN)
- * @param <O> result type (OUT)
*/
public interface QueueKeeper<I> extends AutoCloseable {
import java.util.List;
import java.util.Map;
-import org.opendaylight.openflowplugin.api.openflow.md.core.ConnectionConductor;
import org.opendaylight.openflowplugin.api.openflow.md.core.IMDMessageTranslator;
import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey;
* This processing mechanism based on queue. Processing consists of 2 steps: translate and publish.
* Proposed workflow (might slightly deviate in implementations):
* <ol>
- * <li>messages of input type are pushed in (via {@link QueueProcessor#push(Object, ConnectionConductor)} and similar)</li>
+ * <li>messages of input type are pushed in (via {@link QueueKeeper#push(Object, org.opendaylight.openflowplugin.api.openflow.md.core.ConnectionConductor, org.opendaylight.openflowplugin.api.openflow.md.queue.QueueKeeper.QueueType)} and similar)</li>
* <li>ticket (executable task) is build upon each pushed message and enqueued</li>
* <li>ticket is translated using appropriate translator</li>
* <li>ticket is dequeued and result is published by appropriate popListener</li>
package org.opendaylight.openflowplugin.api.openflow.md.util;
/** List of Openflow versions supported by the plugin
- * Note: If you add a version here, make sure to update {@link OpenflowPortsUtil} as well.
+ * Note: If you add a version here, make sure to update org.opendaylight.openflowplugin.openflow.md.util.OpenflowPortsUtil as well.
* Created by kramesha on 5/2/14.
*/
public enum OpenflowVersion {
* Zipper groups together a list of queues and exposes one poll method. Polling
* iterates through all groups and returns first not-null result of poll method
* on each queue. If after polling each grouped queue for one time there is
- * still null result, poll will return null. <br/>
+ * still null result, poll will return null. <br>
* Iterating keeps last position so this polling is supposed to be fairly
* distributed.
*
- * @param <T>
- * common item type of zipped queues
+ * @param <T> common item type of zipped queues
*/
public class PollableQueuesPriorityZipper<T> {
* Zipper groups together a list of queues and exposes one poll method. Polling iterates through
* all groups and returns first not-null result of poll method on each queue. If after polling each
* grouped queue for one time there is still null result, poll will return null.
- * <br/>
+ * <br>
* Iterating keeps last position so this polling is supposed to be fairly distributed.
*
* @param <T> common item type of zipped queues
* This context is registered with MD-SAL as a routed RPC provider for the inventory node backed by this switch and
* tracks the state of any user requests and how they map onto protocol requests. It uses
* {@link org.opendaylight.openflowplugin.api.openflow.device.RequestContext} to perform requests.
- * <p/>
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
+ * <p>
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public interface RpcContext extends AutoCloseable {
/**
* The RPC Manager will maintain an RPC Context for each online switch. RPC context for device is created when
- * {@link org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceSynchronizedHandler#deviceConnected(org.opendaylight.openflowplugin.api.openflow.device.RequestContext)}
+ * {@link org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceSynchronizedHandler#deviceConnected(org.opendaylight.openflowplugin.api.openflow.device.DeviceContext)}
* is called.
- * <p/>
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
+ * <p>
+ * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public interface RpcManager extends DeviceSynchronizedHandler {
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 27.2.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 27.2.2015.
*/
public interface StatisticsContext {
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceContextReadyHandler;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 26.2.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 26.2.2015.
*/
public interface StatisticsManager extends DeviceContextReadyHandler {
import java.util.Collection;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 27.3.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 27.3.2015.
*/
public class OpenflowPluginProviderImpl implements OpenFlowPluginProvider {
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartRequestInputBuilder;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 26.3.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 26.3.2015.
*/
public final class RequestInputUtils {
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 26.3.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 26.3.2015.
*/
public class RpcResultConvertor<T extends DataObject> {
/**
* after handshake set features, register to session
* @param proposedVersion
- * @param xId
+ * @param xid
* @throws Exception
*/
protected void postHandshake(Short proposedVersion, Long xid) throws Exception {
}
/**
- * Recursive helper method for {@link OFRpcTaskFactory#createAddFlowTask()}
- * and {@link OFRpcTaskFactory#createUpdateFlowTask()} to chain results
+ * Recursive helper method for {@link OFRpcTaskFactory#createAddFlowTask(OFRpcTaskContext, AddFlowInput, SwitchConnectionDistinguisher)}
+ * and {@link OFRpcTaskFactory#createUpdateFlowTask(OFRpcTaskContext, UpdateFlowInput, SwitchConnectionDistinguisher)} to chain results
* of multiple flowmods.
* The next flowmod gets executed if the earlier one is successful.
* All the flowmods should have the same xid, in-order to cross-reference
/**
- * @param xId
* @param input
* @return
*/
/**
* @param task of rpcl
* @param originalResult
- * @param notificationProviderService
- * @param notificationComposer lazy notification composer
* @return chained result with barrier
*/
public static <T extends TransactionAware, I extends DataContainer>
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 13.3.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 13.3.2015.
*/
public final class ActionUtil {
import java.util.Iterator;
/**
- * Created by Martin Bobak <mbobak@cisco.com> on 5.3.2015.
+ * Created by Martin Bobak <mbobak@cisco.com> on 5.3.2015.
*/
public final class IpConversionUtil {
/**
* @param enqueuer
* @param messageSources
- * @param harvestLock
*/
public QueueKeeperHarvester(final Enqueuer<QueueItem<IN>> enqueuer,
final Collection<QueueKeeper<IN>> messageSources) {
}
}
}
-}
\ No newline at end of file
+}
/**
* {@link org.opendaylight.openflowplugin.api.openflow.md.queue.QueueKeeper} implementation focused to keep order and use up mutiple threads for translation phase.
- * <br/>
+ * <br>
* There is internal thread pool of limited size ({@link QueueProcessorLightImpl#setProcessingPoolSize(int)})
* dedicated to translation. Then there is singleThreadPool dedicated to publishing (via popListeners)
- * <br/>
+ * <br>
* Workflow:
* <ol>
* <li>upon message push ticket is created and enqueued</li>
* <li>available threads from internal pool translate the massage wrapped in ticket</li>
- * <li>when translation of particular message is finished, result is set in future result of wrapping ticket</br>
+ * <li>when translation of particular message is finished, result is set in future result of wrapping ticket<br>
* (order of tickets in queue is not touched during translate)
* </li>
* <li>at the end of queue there is {@link TicketFinisher} running in singleThreadPool and for each ticket it does:
/**
* @param capacity
- * @param queueZipper
*/
public WrapperQueueImpl(int capacity, Queue<E> queueDefault,
WaterMarkListener queueListenerMark) {
/**
* learning switch activator
- * <p/>
+ * <p>
* Activator is derived from AbstractBindingAwareConsumer, which takes care
* of looking up MD-SAL in Service Registry and registering consumer
* when MD-SAL is present.
* Creates a path for particular flow, by appending flow-specific information
* to table path.
*
- * @param flowId
- * @param tablePathArg
+ * @param tablePath
+ * @param flowKey
* @return path to flow
*/
- public static InstanceIdentifier<Flow> createFlowPath(InstanceIdentifier<Table> table,FlowKey flowKey) {
- return InstanceIdentifier.builder(table)
+ public static InstanceIdentifier<Flow> createFlowPath(InstanceIdentifier<Table> tablePath, FlowKey flowKey) {
+ return InstanceIdentifier.builder(tablePath)
.child(Flow.class, flowKey)
.build();
}
/**
* Set's Data Broker dependency.
- * <p/>
+ * <p>
* Data Broker is used to access overal operational and configuration
* tree.
- * <p/>
+ * <p>
* In simple Learning Switch handler, data broker is used to listen
* for changes in Openflow tables and to configure flows which will
* be provisioned down to the Openflow switch.
- * <p/>
+ * <p>
* inject {@link DataBroker}
*
* @param data
/**
* Set's Packet Processing dependency.
- * <p/>
+ * <p>
* Packet Processing service is used to send packet Out on Openflow
* switch.
- * <p/>
+ * <p>
* inject {@link PacketProcessingService}
*
* @param packetProcessingService
/**
* Set's Notification service dependency.
- * <p/>
+ * <p>
* Notification service is used to register for listening
* packet-in notifications.
- * <p/>
+ * <p>
* inject {@link NotificationService}
*
* @param notificationService
/**
* @param ci arguments: switchId flowType tableNum
- * <p/>
+ * <p>
* <pre>
* e.g.: addMDFlow openflow:1 f1 42
* </pre>
Code Review / openflowplugin.git / commitdiff