}
/**
- * @param connectionAdapter
- * @param queueProcessor
+ * @param connectionAdapter connection conductor adaptor
+ * @param queueProcessor message queue process
* @return conductor for given connection
*/
public static ConnectionConductor createConductor(ConnectionAdapter connectionAdapter,
private boolean useVersionBitmap;
/**
- * @param connectionAdapter
- * @param highestVersion
- * @param versionOrder
+ * @param connectionAdapter connection adaptor for switch
+ * @param highestVersion highest openflow version
+ * @param versionOrder list of version in order for connection protocol negotiation
*/
public HandshakeManagerImpl(ConnectionAdapter connectionAdapter, Short highestVersion,
List<Short> versionOrder) {
}
/**
- * @param remoteVersion
- * @throws Exception
+ * @param remoteVersion remote version
+ * @throws Exception exception
*/
private void handleStepByStepVersionNegotiation(final Short remoteVersion) throws Exception {
LOG.debug("remoteVersion:{} lastProposedVersion:{}, highestVersion:{}",
}
/**
- * @param remoteVersion
- * @throws Exception
+ * @param remoteVersion remote version
+ * @throws Exception exception
*/
private void handleLowerVersionProposal(Short remoteVersion) throws Exception {
Short proposedVersion;
}
/**
- * @param elements
- * @throws Exception
+ * @param elements version elements
+ * @throws Exception exception
*/
private void handleVersionBitmapNegotiation(List<Elements> elements) throws Exception {
final Short proposedVersion = proposeCommonBitmapVersion(elements);
/**
*
- * @return
+ * @return next tx id
*/
private Long getNextXid() {
activeXid += 1;
}
/**
- * @param xid
+ * @param xid tx id
*/
private void setActiveXid(Long xid) {
this.activeXid = xid;
}
/**
- * @param remoteVersion
+ * @param remoteVersion remove version
*/
private void checkNegotiationStalling(Short remoteVersion) {
if (lastReceivedVersion != null && lastReceivedVersion.equals(remoteVersion)) {
/**
* find common highest supported bitmap version
- * @param list
- * @return
+ * @param list bitmap list
+ * @return proposed bitmap value
*/
protected Short proposeCommonBitmapVersion(List<Elements> list) {
Short supportedHighestVersion = null;
/**
* find supported version based on remoteVersion
- * @param remoteVersion
- * @return
+ * @param remoteVersion openflow version supported by remote entity
+ * @return openflow version
*/
protected short proposeNextVersion(short remoteVersion) {
Short proposal = null;
/**
* send hello reply without versionBitmap
- * @param helloVersion
- * @param helloXid
+ * @param helloVersion initial hello version for openflow connection negotiation
+ * @param helloXid transaction id
* @throws Exception
*/
private ListenableFuture<Void> sendHelloMessage(Short helloVersion, final Long helloXid) throws Exception {
/**
* after handshake set features, register to session
- * @param proposedVersion
- * @param xid
+ * @param proposedVersion proposed openflow version
+ * @param xid transaction id
*/
protected void postHandshake(final Short proposedVersion, final Long xid) {
// set version
/**
- * @param helloMessage
- * @param handshakeManager
- * @param connectionAdapter
+ * @param helloMessage initial hello message
+ * @param handshakeManager connection handshake manager
+ * @param connectionAdapter connection adaptor fro switch
*/
public HandshakeStepWrapper(HelloMessage helloMessage,
HandshakeManager handshakeManager, ConnectionAdapter connectionAdapter) {
}
/**
- * @param extensionConverterProvider
+ * @param extensionConverterProvider extension convertor provider
*/
public void setExtensionConverterProvider(ExtensionConverterProvider extensionConverterProvider) {
this.extensionConverterProvider = extensionConverterProvider;
public abstract class MessageFactory {
/**
- * @param helloVersion
- * @param helloXid
+ * @param helloVersion openflow version for hello message to send to switch
+ * @param helloXid transaction id for hello message
* @return HelloInput without elements
*/
public static HelloInput createHelloInput(short helloVersion, long helloXid) {
}
/**
- * @param highestVersion
- * @param xid
+ * @param highestVersion highest openflow version
+ * @param xid transaction id
* @return builder with prepared header
*/
private static HelloInputBuilder prepareHelloInputBuilder(
}
/**
- * @param helloVersion
- * @param helloXid
- * @param versionOrder
+ * @param helloVersion openflow version for hello message to send to switch
+ * @param helloXid transaction id for hello message
+ * @param versionOrder list of openflow version in order
* @return HelloInput with elements (version bitmap)
*/
public static HelloInput createHelloInput(short helloVersion, long helloXid, List<Short> versionOrder) {
}
/**
- * @param elements
+ * @param elements list of versions
* @return version boolean list
*/
public static List<Boolean> digVersions(List<Elements> elements) {
}
/**
- * @param ofVersion
- * @param ofXid
+ * @param ofVersion openflow version
+ * @param ofXid transaction id
* @return barrier message
*/
public static BarrierInput createBarrier(short ofVersion, long ofXid) {
private DataContainer notSupportedTask = new NoDataContainerTask();
/**
- * @param executorService
+ * @param executorService executor service
*/
public RpcListeningExecutorService(ListeningExecutorService executorService) {
this.executorServiceDelegate = executorService;
public abstract class RpcUtil {
/**
- * @param result
- * @throws Exception
+ * @param result rpc result
+ * @throws Exception exception thrown by method if rpc fails
*/
public static void smokeRpc(RpcResult<?> result) throws Exception {
if (!result.isSuccessful()) {
private static final Logger LOG = LoggerFactory.getLogger(ThreadPoolLoggingExecutor.class);
/**
- * @param corePoolSize
- * @param maximumPoolSize
- * @param keepAliveTime
- * @param unit
- * @param workQueue
+ * @param corePoolSize thread pool size
+ * @param maximumPoolSize maximum pool size
+ * @param keepAliveTime keep alive time
+ * @param unit time unit
+ * @param workQueue task queue
* @param poolName thread name prefix
*/
public ThreadPoolLoggingExecutor(int corePoolSize, int maximumPoolSize,
}
/**
- * @param action
- * @param ofVersion
- * @param actionPath
+ * @param action openflow action
+ * @param ofVersion openflow version
+ * @param actionPath openflow action path
* @return augmentation wrapper containing augmentation depending on matchPath
*/
public static org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action
}
/**
- * @param key
- * @param extConvertor
- * @return
+ * @param key message key
+ * @param extConvertor extension convertor
+ * @return registration closure
*/
private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
RegistrationCloserFromOFJava<FROM, PATH> hireJanitor(
}
/**
- * @param key
- * @param extConvertor
- * @return
+ * @param key message type key
+ * @param extConvertor extension convertor
+ * @return registration closure
*/
private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
RegistrationCloserActionFromOFJava<FROM, PATH> hireJanitor(
}
/**
- * @param key
- * @param extConvertor
- * @return
+ * @param key message type key
+ * @param extConvertor extension convertor
+ * @return registration closure
*/
private <TO extends DataContainer> RegistrationCloserToOFJava<TO> hireJanitor(
final ConverterExtensionKey<? extends ExtensionKey> key, final ConvertorToOFJava<TO> extConvertor) {
}
/**
- * @param key
- * @param extConvertor
- * @return
+ * @param key message type key
+ * @param extConvertor extension convertor
+ * @return registration closure
*/
private <TO extends DataContainer> RegistrationCloserActionToOFJava<TO> hireJanitor(
final TypeVersionKey<? extends Action> key, final ConvertorActionToOFJava<Action, TO> extConvertor) {
}
/**
- * @param key
- * @param extConvertor
- * @return
+ * @param key message type key
+ * @param extConvertor extension convertor
+ * @return registration closure
*/
private <TO extends DataContainer, K extends ExperimenterMessageOfChoice> RegistrationCloserMessageToOFJava<TO, K> hireMessageJanitor(
final TypeVersionKey<K> key,
}
/**
- * @param key
- * @param extConvertor
- * @return
+ * @param key message type key
+ * @param extConvertor extension convertor
+ * @return registration closure
*/
private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
RegistrationCloserMessageFromOFJava<FROM, PATH> hireMessageJanitor(
/**
* cancel registration of given converter
*
- * @param key
- * @param converter
+ * @param key message key
+ * @param converter extension convertor
*/
public void unregister(final ConverterExtensionKey<?> key, final ConvertorToOFJava<?> converter) {
ConvertorToOFJava<?> registeredConverter = registryToOFJAva.get(key);
/**
* cancel registration of given converter
*
- * @param key
- * @param converter
+ * @param key message key
+ * @param converter extension convertor
*/
public void unregister(final TypeVersionKey<? extends Action> key, final ConvertorActionToOFJava<?, ?> converter) {
ConvertorActionToOFJava<?, ?> registeredConverter = registryActionToOFJAva.get(key);
/**
* cancel registration of given converter
*
- * @param key
- * @param converter
+ * @param key message key
+ * @param converter extension convertor
*/
public void unregister(final MessageTypeKey<?> key, final ConvertorFromOFJava<?, ?> converter) {
ConvertorFromOFJava<?, ?> registeredConverter = registryFromOFJAva.get(key);
/**
* cancel registration of given converter
*
- * @param key
- * @param converter
+ * @param key message key
+ * @param converter extension convertor
*/
public void unregister(final MessageTypeKey<?> key, final ConvertorActionFromOFJava<?, ?> converter) {
ConvertorActionFromOFJava<?, ?> registeredConverter = registryActionFromOFJAva.get(key);
/**
* cancel registration of given converter
*
- * @param key
- * @param converter
+ * @param key message key
+ * @param converter extension convertor
*/
public void unregister(final MessageTypeKey<?> key, final ConvertorMessageFromOFJava<?, ?> converter) {
ConvertorMessageFromOFJava<?, ?> registeredConverter = registryMessageFromOFJAva.get(key);
/**
* cancel registration of given converter
*
- * @param key
- * @param converter
+ * @param key message key
+ * @param converter extension convertor
*/
public void unregister(final TypeVersionKey<?> key, final ConvertorMessageToOFJava<?, ?> converter) {
ConvertorMessageToOFJava<?, ?> registeredConverter = registryMessageToOFJAva.get(key);
}
/**
- * @param matchEntries
- * @param ofVersion
- * @param matchPath
+ * @param matchEntries match entries
+ * @param ofVersion openflow version
+ * @param matchPath match path
+ * @param <EXT_POINT> extension point
* @return augmentation wrapper containing augmentation depending on matchPath
*/
@SuppressWarnings("unchecked")
.getLogger(OFRpcFutureResultTransformFactory.class);
/**
- * @param input
- * @param result
- * @return
+ *
+ * @param input rpc result input
+ * @param result results
+ * @param <E> rpc result input type
+ * @return rpc result
*/
protected static <E> RpcResult<E> assembleRpcResult(RpcResult<?> input, E result) {
Collection<RpcError> errors = input.getErrors();
}
/**
- * @return
+ * @return rpc result function for group udpate
*/
public static Function<RpcResult<UpdateGroupOutput>,RpcResult<RemoveGroupOutput>> createForRemoveGroupOutput() {
return new Function<RpcResult<UpdateGroupOutput>,RpcResult<RemoveGroupOutput>>() {
/**
- * @return
+ * @return return rpc result function
*/
public static Function<RpcResult<UpdateMeterOutput>, RpcResult<RemoveMeterOutput>> createForRemoveMeterOutput() {
return new Function<RpcResult<UpdateMeterOutput>,RpcResult<RemoveMeterOutput>>() {
private SwitchConnectionDistinguisher cookie;
/**
- * @param taskContext
- * @param input
- * @param cookie
+ * @param taskContext rpc task context
+ * @param input task input
+ * @param cookie switch connection distinguisher cookie value
*/
public OFRpcTask(OFRpcTaskContext taskContext, SwitchConnectionDistinguisher cookie, T input) {
this.taskContext = taskContext;
this.maxTimeoutUnit = maxTimeoutUnit;
}
/**
- * @param rpcPool
+ * @param rpcPool executor service pool for rpc
*/
public void setRpcPool(ListeningExecutorService rpcPool) {
this.rpcPool = rpcPool;
}
/**
- * @param messageSpy
+ * @param messageSpy the message spy
*/
public void setMessageSpy(MessageSpy<DataContainer> messageSpy) {
this.messageSpy = messageSpy;
}
/**
- * @param taskContext
- * @param input
- * @param cookie
+ * @param taskContext task context
+ * @param input flow object input
+ * @param cookie switch connection distinguisher cookie value
* @return UpdateFlow task
*/
public static OFRpcTask<AddFlowInput, RpcResult<UpdateFlowOutput>> createAddFlowTask(
* The next flowmod gets executed if the earlier one is successful.
* All the flowmods should have the same xid, in-order to cross-reference
* the notification
+ * @param taskContext task context
+ * @param ofFlowModInputs list of flow mod as input
+ * @param index starting index
+ * @param cookie switch connection distinguisher
+ * @return listenable future with update flow output
+ *
*/
protected static ListenableFuture<RpcResult<UpdateFlowOutput>> chainFlowMods(
final List<FlowModInputBuilder> ofFlowModInputs, final int index,
/**
- * @param input
- * @return
+ * @param input flow input
+ * @return flow added notification
*/
protected static NotificationComposer<FlowAdded> createFlowAddedNotification(
final AddFlowInput input) {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
+ * @param taskContext task context
+ * @param input update flow input
+ * @param cookie switch connection distinguisher cookie value
+ * @param rwTx read write transaction
* @return UpdateFlow task
*/
public static OFRpcTask<UpdateFlowInput, RpcResult<UpdateFlowOutput>> createUpdateFlowTask(
/**
- * @param input
- * @return
+ * @param input update flow input
+ * @return flow update notification
*/
protected static NotificationComposer<FlowUpdated> createFlowUpdatedNotification(final UpdateFlowInput input) {
return new NotificationComposer<FlowUpdated>() {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
+ * @param taskContext taks context
+ * @param input group update input
+ * @param cookie switch connection distinguisher cookie value
* @return update group task
*/
public static OFRpcTask<AddGroupInput, RpcResult<UpdateGroupOutput>> createAddGroupTask(
/**
- * @param input
- * @return
+ * @param input group add input
+ * @return group added notification
*/
protected static NotificationComposer<GroupAdded> createGroupAddedNotification(
final AddGroupInput input) {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
+ * @param taskContext task context
+ * @param input meter add input
+ * @param cookie switch connection distinguisher
* @return update meter task
*/
public static OFRpcTask<AddMeterInput, RpcResult<UpdateMeterOutput>> createAddMeterTask(
}
/**
- * @param input
- * @return
+ * @param input add meter input
+ * @return meter added notification composer
*/
protected static NotificationComposer<MeterAdded> createMeterAddedNotification(
final AddMeterInput input) {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
+ * @param taskContext task context
+ * @param input update group output
+ * @param cookie switch connection distinguisher cookie value
* @return UpdateFlow task
*/
public static OFRpcTask<UpdateGroupInput, RpcResult<UpdateGroupOutput>> createUpdateGroupTask(
}
/**
- * @param input
- * @return
+ * @param input group update input
+ * @return group updated notification composer
*/
protected static NotificationComposer<GroupUpdated> createGroupUpdatedNotification(
final UpdateGroupInput input) {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
+ * @param taskContext task context
+ * @param input update meter input
+ * @param cookie switch connection distinguisher cookie value
* @return update meter task
*/
public static OFRpcTask<UpdateMeterInput, RpcResult<UpdateMeterOutput>> createUpdateMeterTask(
}
/**
- * @param input
- * @return
+ * @param input meter update input
+ * @return meter updated notification
*/
protected static NotificationComposer<MeterUpdated> createMeterUpdatedNotification(
final UpdateMeterInput input) {
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input update flow input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task remove flow task
*/
public static OFRpcTask<RemoveFlowInput, RpcResult<UpdateFlowOutput>> createRemoveFlowTask(
OFRpcTaskContext taskContext, RemoveFlowInput input,
}
/**
- * @param input
- * @return
+ * @param input remove flow input
+ * @return flow removed notification
*/
protected static NotificationComposer<FlowRemoved> createFlowRemovedNotification(
final RemoveFlowInput input) {
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input remove group input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task remove group task
*/
public static OFRpcTask<RemoveGroupInput, RpcResult<UpdateGroupOutput>> createRemoveGroupTask(
final OFRpcTaskContext taskContext, RemoveGroupInput input,
}
/**
- * @param input
- * @return
+ * @param input group remove input
+ * @return group removed notification
*/
protected static NotificationComposer<GroupRemoved> createGroupRemovedNotification(
final RemoveGroupInput input) {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input meter removed input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task meter remove task
*/
public static OFRpcTask<RemoveMeterInput, RpcResult<UpdateMeterOutput>> createRemoveMeterTask(
OFRpcTaskContext taskContext, RemoveMeterInput input,
}
/**
- * @param input
- * @return
+ * @param input remove meter input
+ * @return meter removed notification composer
*/
protected static NotificationComposer<MeterRemoved> createMeterRemovedNotification(
final RemoveMeterInput input) {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get all statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get all group statistics task
*/
public static OFRpcTask<GetAllGroupStatisticsInput, RpcResult<GetAllGroupStatisticsOutput>> createGetAllGroupStatisticsTask(
final OFRpcTaskContext taskContext, GetAllGroupStatisticsInput input,
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get group description input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get group description task
*/
public static OFRpcTask<GetGroupDescriptionInput, RpcResult<GetGroupDescriptionOutput>> createGetGroupDescriptionTask(
final OFRpcTaskContext taskContext, GetGroupDescriptionInput input,
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get group feature input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get group feature task
*/
public static OFRpcTask<GetGroupFeaturesInput, RpcResult<GetGroupFeaturesOutput>> createGetGroupFeaturesTask(
final OFRpcTaskContext taskContext, GetGroupFeaturesInput input,
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get group statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get group statistics task
*/
public static OFRpcTask<GetGroupStatisticsInput, RpcResult<GetGroupStatisticsOutput>> createGetGroupStatisticsTask(
final OFRpcTaskContext taskContext, final GetGroupStatisticsInput input,
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get meter config statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get all mtere config statistics task
*/
public static OFRpcTask<GetAllMeterConfigStatisticsInput, RpcResult<GetAllMeterConfigStatisticsOutput>> createGetAllMeterConfigStatisticsTask(
final OFRpcTaskContext taskContext, final GetAllMeterConfigStatisticsInput input,
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get all meter statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get all meter statistics task
*/
public static OFRpcTask<GetAllMeterStatisticsInput, RpcResult<GetAllMeterStatisticsOutput>> createGetAllMeterStatisticsTask(
final OFRpcTaskContext taskContext, final GetAllMeterStatisticsInput input,
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get meter features input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get meter feature task
*/
public static OFRpcTask<GetMeterFeaturesInput, RpcResult<GetMeterFeaturesOutput>> createGetMeterFeaturesTask(
final OFRpcTaskContext taskContext, final GetMeterFeaturesInput input,
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get meter statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get meter statistics task
*/
public static OFRpcTask<GetMeterStatisticsInput, RpcResult<GetMeterStatisticsOutput>> createGetMeterStatisticsTask(
final OFRpcTaskContext taskContext, final GetMeterStatisticsInput input,
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get all node connector statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get all node connector statistics task
*/
public static OFRpcTask<GetAllNodeConnectorsStatisticsInput, RpcResult<GetAllNodeConnectorsStatisticsOutput>>
createGetAllNodeConnectorsStatisticsTask(
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get node connector statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get node connector statistics task
*/
public static OFRpcTask<GetNodeConnectorStatisticsInput, RpcResult<GetNodeConnectorStatisticsOutput>>
createGetNodeConnectorStatisticsTask(
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get all flow statistics from flow table
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get all flow statistics from flow table task
*/
public static OFRpcTask<GetAllFlowStatisticsFromFlowTableInput, RpcResult<GetAllFlowStatisticsFromFlowTableOutput>>
createGetAllFlowStatisticsFromFlowTableTask(
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get all flow statistics from all flow table
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get all flow statistics from all flow table task
*/
public static OFRpcTask<GetAllFlowsStatisticsFromAllFlowTablesInput, RpcResult<GetAllFlowsStatisticsFromAllFlowTablesOutput>>
createGetAllFlowsStatisticsFromAllFlowTablesTask(
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get flow statistics from flow table
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get flow statistics from flow table task
*/
public static OFRpcTask<GetFlowStatisticsFromFlowTableInput, RpcResult<GetFlowStatisticsFromFlowTableOutput>>
createGetFlowStatisticsFromFlowTableTask(
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input get aggregate flow statistics from flow table for all flow input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task get aggregate flow stats from flow table for all flow task
*/
public static OFRpcTask<GetAggregateFlowStatisticsFromFlowTableForAllFlowsInput, RpcResult<GetAggregateFlowStatisticsFromFlowTableForAllFlowsOutput>>
createGetAggregateFlowStatisticsFromFlowTableForAllFlowsTask(
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input aggregate flow statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task task to fetch the statistics
*/
public static OFRpcTask<GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput, RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>>
createGetAggregateFlowStatisticsFromFlowTableForGivenMatchTask(
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input flow table statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task task to fetch table statistics
*/
public static OFRpcTask<GetFlowTablesStatisticsInput, RpcResult<GetFlowTablesStatisticsOutput>> createGetFlowTablesStatisticsTask(
final OFRpcTaskContext taskContext, final GetFlowTablesStatisticsInput input, SwitchConnectionDistinguisher cookie) {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input queue statistics input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task task to fetch all queue statistics
*/
public static OFRpcTask<GetAllQueuesStatisticsFromAllPortsInput, RpcResult<GetAllQueuesStatisticsFromAllPortsOutput>> createGetAllQueuesStatisticsFromAllPortsTask(
final OFRpcTaskContext taskContext, final GetAllQueuesStatisticsFromAllPortsInput input, SwitchConnectionDistinguisher cookie) {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input queue statist from specific port input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task task to get queue statistics from specific port
*/
public static OFRpcTask<GetAllQueuesStatisticsFromGivenPortInput, RpcResult<GetAllQueuesStatisticsFromGivenPortOutput>> createGetAllQueuesStatisticsFromGivenPortTask(
final OFRpcTaskContext taskContext, final GetAllQueuesStatisticsFromGivenPortInput input, SwitchConnectionDistinguisher cookie) {
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input queue statistics from given port
+ * @param cookie switch connection distinguisher cookie value
+ * @return task task to get queue statistics from given port
*/
public static OFRpcTask<GetQueueStatisticsFromGivenPortInput, RpcResult<GetQueueStatisticsFromGivenPortOutput>> createGetQueueStatisticsFromGivenPortTask(
final OFRpcTaskContext taskContext, final GetQueueStatisticsFromGivenPortInput input, SwitchConnectionDistinguisher cookie) {
private SettableFuture<RpcResult<T>> result;
/**
- * @param result
+ * @param result result
*/
public ResultCallback(SettableFuture<RpcResult<T>> result) {
this.result = result;
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input update port input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task task to update port
*/
public static OFRpcTask<UpdatePortInput, RpcResult<UpdatePortOutput>> createUpdatePortTask(
final OFRpcTaskContext taskContext, final UpdatePortInput input,
}
/**
- * @param taskContext
- * @param input
- * @param cookie
- * @return task
+ * @param taskContext task context
+ * @param input update table input
+ * @param cookie switch connection distinguisher cookie value
+ * @return task task to udpate table input
*/
public static OFRpcTask<UpdateTableInput, RpcResult<UpdateTableOutput>> createUpdateTableTask(
final OFRpcTaskContext taskContext, final UpdateTableInput input,
}
/**
- * @param task of rpc
- * @param originalResult
- * @param notificationProviderService
+ * @param task task
+ * @param originalResult original result
+ * @param notificationProviderService notification provider service
* @param notificationComposer lazy notification composer
+ * @param <I> data container
+ * @param <N> notification
+ * @param <R> R
*/
public static <R extends RpcResult<? extends TransactionAware>, N extends Notification, I extends DataContainer>
void hookFutureNotification(
}
/**
- * @param task of rpcl
- * @param originalResult
+ * @param task of rpc
+ * @param originalResult original result
+ * @param <T> R
+ * @param <I> I
* @return chained result with barrier
*/
public static <T extends TransactionAware, I extends DataContainer>
}
/**
- * @param originalInput
- * @return
+ * @param originalInput original input
+ * @param barrierInput barrier input
+ * @param <T> T
+ * @return result
*/
protected static <T extends TransactionAware> Function<RpcResult<BarrierOutput>, RpcResult<T>> transformBarrierToTransactionAware(
final RpcResult<T> originalInput, final BarrierInput barrierInput) {
*
* @param actions SAL actions
* @param version Openflow protocol version used
- * @param datapathid
+ * @param datapathid datapath id
* @param flow TODO
* @return OF Library actions
*/
/**
* Method to convert OF actions associated with bucket to SAL Actions.
*
- * @param actionList
+ * @param actionList action list
* @param ofVersion current ofp version
* @param actionPath TODO
* @return List of converted SAL Actions.
/**
* Method converts OF Output action object to SAL Output action object.
*
- * @param ofVersion
- * @param ofVersion
+ * @param ofVersion openflow version
* @param action org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.
* action.rev130731.actions.actions.list.Action
* @return OutputAction
/**
* Method converts OF GroupAction object to SAL GroupAction object
*
- * @param action
- * @return GroupAction
+ * @param action action
+ * @return GroupAction group action
*/
public static GroupActionCase ofToSALGroupAction(final Action action) {
GroupCase actionCase = (GroupCase) action.getActionChoice();
* Method converts OF SetMplsTTL action object to SAL SetMplsTTL action
* object.
*
- * @param action
- * @return
+ * @param action action
+ * @return set-mpls ttl action
*/
public static SetMplsTtlActionCase ofToSALSetMplsTtl(final Action action) {
SetMplsTtlCase actionCase = (SetMplsTtlCase) action.getActionChoice();
/**
* Method converts OF Pushvlan action to SAL PushVlan action.
*
- * @param action
+ * @param action input actioj
* @return PushVlanAction
*/
public static PushVlanActionCase ofToSALPushVlanAction(final Action action) {
/**
* Method converts OF PushMpls action to SAL PushMpls action.
*
- * @param action
+ * @param action action
* @return PushMplsAction
*/
public static PushMplsActionCase ofToSALPushMplsAction(final Action action) {
/**
* Method converts OF PopMpls action to SAL PopMpls action.
*
- * @param action
+ * @param action action
* @return PopMplsActionCase
*/
public static PopMplsActionCase ofToSALPopMplsAction(final Action action) {
/**
* Method converts OF SetQueue action to SAL SetQueue action.
*
- * @param action
+ * @param action action
* @return SetQueueAction
*/
public static SetQueueActionCase ofToSALSetQueue(final Action action) {
/**
* Method converts OF SetNwTtl action to SAL SetNwTtl action.
*
- * @param action
+ * @param action action
* @return SetNwTtlAction
*/
public static SetNwTtlActionCase ofToSALSetNwTtl(final Action action) {
/**
* Method converts OF Pushvlan action to SAL PushVlan action.
*
- * @param action
+ * @param action action
* @return PushVlanAction
*/
public static PushPbbActionCase ofToSALPushPbbAction(final Action action) {
* This method converts the SAL Flow to OF Flow.
* It checks if there is a set-vlan-id (1.0) action made on OF1.3.
* If yes its handled separately
+ *
+ * @param srcFlow source flow
+ * @param version openflow version
+ * @param datapathId datapath id
+ * @return list of flow mod build
*/
public static List<FlowModInputBuilder> toFlowModInputs(Flow srcFlow, short version, BigInteger datapathId) {
if (version >= OFConstants.OFP_VERSION_1_3 && isSetVlanIdActionCasePresent(srcFlow)) {
/**
* Method returns the list of MD-SAL format flow statistics, converted flow Openflow
* specific flow statistics.
- * @param allFlowStats
- * @return
+ * @param allFlowStats all flow stats
+ * @param datapathid datapath id
+ * @param ofVersion openflow version
+ * @return list of flow and statistics mapping
*/
public List<FlowAndStatisticsMapList> toSALFlowStatsList(List<FlowStats> allFlowStats, BigInteger datapathid, OpenflowVersion ofVersion){
/**
* Method convert Openflow switch specific flow statistics to the MD-SAL format
* flow statistics.
- * @param flowStats
- * @return
+ * @param flowStats flow statis
+ * @param datapathid datapath id
+ * @param ofVersion openflow version
+ * @return flow and statistics map
*/
public FlowAndStatisticsMapList toSALFlowStats(FlowStats flowStats, BigInteger datapathid, OpenflowVersion ofVersion){
FlowAndStatisticsMapListBuilder salFlowStatsBuilder = new FlowAndStatisticsMapListBuilder();
/**
* Print a v6 prefix in byte array + 1 notation
- *
* @param _binary_form - prefix, in byte [] form, last byte is netmask
+ * @return string of v6 prefix
+ * @throws UnknownHostException unknown host exception
*/
public static String byteArrayV6PrefixToString(final byte [] _binary_form) throws UnknownHostException {
/* NO DIY!!! - InetAddresses will actually print correct canonical
// Get all the data for the meter from the Yang/SAL-Layer
/**
- * @param version
- * @param source
- * Data source
+ * @param version of version
+ * @param source Data source
* @return MeterModInput required by OF Library
*/
public static MeterModInputBuilder toMeterModInput(
/**
* Method converts list of OF Meter Stats to SAL Meter Stats.
*
- * @param allMeterStats
+ * @param allMeterStats all meter stats
* @return List of MeterStats
*/
public List<MeterStats> toSALMeterStatsList(
/**
* Method convert list of OF Meter config Stats to SAL Meter Config stats
*
- * @param allMeterConfigs
+ * @param allMeterConfigs all meter configs
* @return list of MeterConfigStats
*/
public List<MeterConfigStats> toSALMeterConfigList(List<MeterConfig> allMeterConfigs) {
* Method convert Openflow 1.3+ specific instructions to MD-SAL format
* flow instruction
*
- * @param instructions
+ * @param instructions instructions
* @param ofVersion current ofp version
- * @return
+ * @return instruction converted to SAL instruction
*/
public static Instructions toSALInstruction(
List<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.instruction.rev130731.instructions.grouping.Instruction> instructions, OpenflowVersion ofVersion) {
* Method wraps openflow 1.0 actions list to Apply Action Instructions
*
* @param ofVersion current ofp version
+ * @param actionsList list of action
+ * @return OF10 actions as an instructions
*/
public static Instructions wrapOF10ActionsToInstruction(
// Get all the data for the PacketOut from the Yang/SAL-Layer
/**
- * @param version
- * @param inputPacket
+ * @param version openflow version
+ * @param inputPacket input packet
+ * @param datapathid datapath id
+ * @param xid tx id
* @return PacketOutInput required by OF Library
*/
public static PacketOutInput toPacketOutInput(final TransmitPacketInput inputPacket, final short version, final Long xid,
/**
* This method is used by PORT_MOD_MESSAGE
*
- * @param source
- * @return
+ * @param source source port
+ * @param version openflow version
+ * @return port mod input
*/
public static PortModInput toPortModInput(
* message(OF1.3.1)
*/
/**
- * @param source
- * :SAL FlowCapablePort
+ * @param source FlowCapablePort
+ * @param version openflow version
* @return OF:Ports
*/
public static Ports toPortDesc(
public class ActionSetNwDstReactorMappingFactory {
/**
- * @param conversionMapping
+ * @param conversionMapping conversion mapping
*/
public static void addSetNwDstConvertors(final Map<Short, Convertor<SetNwDstActionCase, ?>> conversionMapping) {
conversionMapping.put(OFConstants.OFP_VERSION_1_0, new ActionSetNwDstConvertorV10Impl());
}
/**
- * @param injectionMapping
+ * @param injectionMapping injection mapping
*/
public static void addSetNwDstInjectors(final Map<InjectionKey, ResultInjector<?, ?>> injectionMapping) {
// OF-1.0| Ipv4Address -> ActionBuilder; SetNwDst
public class ActionSetNwSrcReactorMappingFactory {
/**
- * @param conversionMapping
+ * @param conversionMapping conversion mapping
*/
public static void addSetNwSrcConvertors(final Map<Short, Convertor<SetNwSrcActionCase, ?>> conversionMapping) {
conversionMapping.put(OFConstants.OFP_VERSION_1_0, new ActionSetNwSrcConvertorV10Impl());
}
/**
- * @param injectionMapping
+ * @param injectionMapping injection mapping
*/
public static void addSetNwSrcInjectors(final Map<InjectionKey, ResultInjector<?, ?>> injectionMapping) {
// OF-1.0| Ipv4Address -> ActionBuilder; SetNwSrc
/**
* fill conversion and injection mappings
- * @param conversions
- * @param injections
+ * @param conversions convert from
+ * @param injections injection
*/
protected abstract void initMappings(Map<Short, Convertor<FROM, ?>> conversions,
Map<InjectionKey, ResultInjector<?, ?>> injections);
/**
- * @param source
- * @param version
- * @param target
- * @param datapathid
+ * @param source convert from
+ * @param version openflow version
+ * @param target convert to
+ * @param datapathid datapath id
+ * @param <RESULT> result
+ * @param <TARGET> target
*/
@SuppressWarnings("unchecked")
public <RESULT, TARGET> void convert(final FROM source, final short version, final TARGET target, final BigInteger datapathid) {
}
/**
- * @param version
+ * @param version openflow version
* @param convertedItem to be injected
* @param target object
- * @return
+ * @return injection key
*/
protected InjectionKey buildInjectionKey(final short version, final Object convertedItem, final Object target) {
return new InjectionKey(version, target.getClass());
public interface Convertor<FROM, TO> {
/**
- * @param source
- * @param datapathid
+ * @param source source type
+ * @param datapathid datapath id
* @return converted match (into OF-API model)
*/
TO convert(FROM source,BigInteger datapathid);
private final Class<?> targetClazz;
/**
- * @param version
- * @param targetClazz
+ * @param version openflow version
+ * @param targetClazz target class
*/
public InjectionKey(final int version, final Class<?> targetClazz) {
this.version = version;
private final Class<?> resultClazz;
/**
- * @param version
- * @param targetClazz
- * @param resultClazz
+ * @param version openflow version
+ * @param targetClazz target class
+ * @param resultClazz result class
*/
public InjectionResultTargetKey(final int version, final Class<?> targetClazz, final Class<?> resultClazz) {
super(version, targetClazz);
/**
* Comparator for comparing objects which extend Ordered.
*
- * @param <T>
+ * @param <T> T
*/
public class OrderComparator<T extends Ordered> implements Comparator<T> {
public interface ResultInjector<R, T> {
/**
- * @param result
- * @param target
+ * @param result result
+ * @param target target
*/
void inject(R result, T target);
public interface FlowFlagConvertor<E> extends Convertor<FlowModFlags, E> {
/**
- * @param source
+ * @param source flow mode flags
+ * @param datapathid datapath id
* @return converted match (into OF-API model)
*/
@Override
public class FlowFlagReactorMappingFactory {
/**
- * @param conversionMapping
+ * @param conversionMapping conversion mapping
*/
public static void addFlowFlagsConvertors(final Map<Short, Convertor<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowModFlags, ?>> conversionMapping) {
conversionMapping.put(OFConstants.OFP_VERSION_1_3, new FlowFlagsConvertorImpl());
}
/**
- * @param injectionMapping
+ * @param injectionMapping injection mapping
*/
public static void addFlowFlagsIjectors(final Map<InjectionKey, ResultInjector<?, ?>> injectionMapping) {
// OF-1.3|FlowModFlags --> FlowModInputBuilder
public interface MatchConvertor<E> extends Convertor<Match, E> {
/**
- * @param source
+ * @param source match input
+ * @param datapathid datapath id
* @return converted match (into OF-API model)
*/
@Override
/**
* Method convert Openflow 1.0 specific flow match to MD-SAL format flow
* match
- *
- * @param swMatch
- * @return
- * @author avishnoi@in.ibm.com
+ * @param swMatch source match
+ * @param datapathid datapath id
+ * @param ofVersion openflow version
+ * @return match builder
*/
public static MatchBuilder fromOFMatchV10ToSALMatch(@Nonnull final MatchV10 swMatch, @Nonnull final BigInteger datapathid, @Nonnull final OpenflowVersion ofVersion) {
MatchBuilder matchBuilder = new MatchBuilder();
* Method converts Openflow 1.3+ specific flow match to MD-SAL format flow
* match
*
- * @param swMatch
- * @param swMatch
- * @param datapathid
- * @param ofVersion
+ * @param swMatch source match
+ * @param datapathid datapath id
+ * @param ofVersion openflow version
* @return md-sal match instance
* @author avishnoi@in.ibm.com
*/
/**
* Method converts OF SetField action to SAL SetFiled action.
*
- * @param action
+ * @param action input action
* @param ofVersion current ofp version
- * @return
+ * @return set field builder
*/
public static SetField fromOFSetFieldToSALSetFieldAction(
final Action action, final OpenflowVersion ofVersion) {
private static final String PREFIX_SEPARATOR = "/";
/**
- * @param pField
+ * @param pField ipv6 external header flag
* @return integer containing lower 9 bits filled with corresponding flags
*/
public static Integer ipv6ExthdrFlagsToInt(final Ipv6ExthdrFlags pField) {
public class MatchReactorMappingFactory {
/**
- * @param conversionMapping
+ * @param conversionMapping conversion mapping
*/
public static void addMatchConvertors(final Map<Short, Convertor<Match, ?>> conversionMapping) {
conversionMapping.put(OFConstants.OFP_VERSION_1_3, new MatchConvertorImpl());
}
/**
- * @param injectionMapping
+ * @param injectionMapping injection mapping
*/
public static void addMatchIjectors(final Map<InjectionKey, ResultInjector<?, ?>> injectionMapping) {
// OF-1.3|List<MatchEntries> --> FlowModInputBuilder
/**
*
- * @param port
+ * @param port port group
* @return port bandwidth
*/
public boolean getBandwidth(PortGrouping port);
private final SessionManager sessionManager;
/**
- * @param sessionManager
+ * @param sessionManager switch connection session manager
*/
public OFRoleManager(final SessionManager sessionManager) {
Preconditions.checkNotNull("Session manager can not be empty.", sessionManager);
/**
* change role on each connected device
*
- * @param role
+ * @param role openflow role
*/
public void manageRoleChange(final OfpRole role) {
for (final SessionContext session : sessionManager.getAllSessions()) {
/**
* default ctor
*
- * @param message
+ * @param message exception message
*/
public RolePushException(String message) {
super(message);
}
/**
- * @param message
- * @param cause
+ * @param message exception message
+ * @param cause exception cause
*/
public RolePushException(String message, Throwable cause) {
super(message, cause);
private long cookie;
/**
- * @param cookie
+ * @param cookie switch connection cookie
*/
public SwitchConnectionCookieOFImpl(long cookie) {
this.cookie = cookie;
}
/**
- * @param auxiliaryId
- * the auxiliaryId to set
+ * @param auxiliaryId the auxiliaryId to set
*/
public void setAuxiliaryId(short auxiliaryId) {
this.auxiliaryId = auxiliaryId;
}
/**
- * @param message
- * @param errorType
- * @param node
- * @return
+ * @param message error message
+ * @param errorType error type
+ * @param node node ref
+ * @return error message
*/
protected abstract org.opendaylight.yang.gen.v1.urn.opendaylight.flow.errors.rev131116.ErrorMessage getGranularNodeErrors(ErrorMessage message, ErrorType errorType, NodeRef node);
}
/**
- * @param message
- * @param errorType
- * @param node
+ * @param message error message
+ * @param errorType error type
+ * @param node reference to node, that sent the error message
* @return translated error message of general type (OF-1.0)
*/
@Override
private IN messageSource;
/**
- * @param messageSourceRegistry
- * @param messageSource
+ * @param messageSourceRegistry message source registry
+ * @param messageSource message source
*/
public MessageSourcePollRegistration(MessageSourcePollRegistrator<IN> messageSourceRegistry,
IN messageSource) {
/**
- * @param message
- * @param connectionConductor
- * @param queueType
+ * @param message openflow message
+ * @param connectionConductor switch connection conductor
+ * @param queueType queue type
*/
public QueueItemOFImpl(OfHeader message,
ConnectionConductor connectionConductor, QueueType queueType) {
public abstract class QueueKeeperFactory {
/**
- * @param sourceRegistrator
- * @param capacity
- * blocking queue capacity
- * @param waterMarkListener
+ * @param sourceRegistrator source registrator
+ * @param capacity blocking queue capacity
+ * @param waterMarkListener water mark listener
* @return fair reading implementation of
* {@link org.opendaylight.openflowplugin.api.openflow.md.queue.QueueKeeper}
* (not registered = not started yet)
* {@link QueueKeeperFairImpl#close()} to kill the queue and stop
* processing.
*
- * @param sourceRegistrator
- * @param queueKeeper
+ * @param sourceRegistrator source registrator
+ * @param queueKeeper queue keeper
*/
public static <V> void plugQueue(
MessageSourcePollRegistrator<QueueKeeper<V>> sourceRegistrator,
}
/**
- * @param harvesterHandle
+ * @param harvesterHandle harvester handle
*/
public void setHarvesterHandle(HarvesterHandle harvesterHandle) {
this.harvesterHandle = harvesterHandle;
import org.slf4j.LoggerFactory;
/**
- * @param <IN>
+ * @param <IN> Type of queue keeper harvester
*
*/
public class QueueKeeperHarvester<IN> implements Runnable, HarvesterHandle {
private volatile boolean wakeMe = false;
/**
- * @param enqueuer
- * @param messageSources
+ * @param enqueuer queue enqueuer
+ * @param messageSources source of message
*/
public QueueKeeperHarvester(final Enqueuer<QueueItem<IN>> enqueuer,
final Collection<QueueKeeper<IN>> messageSources) {
/**
* notify popListeners
- * @param processedMessages
+ * @param processedMessages processed message
*/
void firePopNotification(List<OUT> processedMessages);
}
private BlockingQueue<TicketResult<DataObject>> queue;
/**
- * @param queue
- * @param popListenersMapping
+ * @param queue ticket queue
+ * @param popListenersMapping message pop listener
*/
public TicketFinisherImpl(BlockingQueue<TicketResult<DataObject>> queue,
Map<Class<? extends DataObject>, Collection<PopListener<DataObject>>> popListenersMapping) {
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
- * @param <IN>
- * @param <OUT>
+ * @param <IN> type of DataObject
+ * @param <OUT> type of DataObject
*/
public interface TicketProcessorFactory<IN extends DataObject, OUT extends DataObject> {
/**
- * @param ticket
+ * @param ticket ticket
* @return runnable ticket processor
*/
Runnable createProcessor(final Ticket<IN, OUT> ticket);
/**
- * @param ticket
+ * @param ticket ticket
* @return runnable ticket processor
*/
Runnable createSyncProcessor(final Ticket<IN, OUT> ticket);
/**
- * @param ticket
+ * @param ticket ticket
* @return translated messages
*
*/
}
/**
- * @param ticket
+ * @param ticket ticket
* @return runnable ticket processor
*/
@Override
}
/**
- * @param ticket
+ * @param ticket ticket
* @return runnable ticket processor
*/
@Override
/**
- * @param ticket
+ * @param ticket ticket
*
*/
@Override
private static final BaseEncoding HEX_16_ENCODING = PLAIN_HEX_16_ENCODING.withSeparator(DEFAULT_HEX_SEPARATOR, 2);
/**
- * @param bytes
- * @param delimiter
+ * @param bytes bytes that needs to be converted to hex
+ * @param delimiter string delimiter
* @return hexString containing bytes, separated with delimiter
*/
public static String bytesToHexstring(final byte[] bytes, final String delimiter) {
/**
* Utility method to convert BigInteger to n element byte array
*
- * @param bigInteger
+ * @param bigInteger big integer value that needs to be converted to byte
+ * @param numBytes convert to number of bytes
* @return byte array containing n * 8 bits.
*/
public static byte[] convertBigIntegerToNBytes(final BigInteger bigInteger, final int numBytes) {
/**
* Method creates openflow 1.0 format match, that can match all the flow entries.
*
- * @return
+ * @return V10 Match object
*/
public static MatchV10 createWildcardedMatchV10() {
MatchV10Builder builder = new MatchV10Builder();
}
/**
- * @param dataPathId
+ * @param dataPathId datapath id in big interger value
* @return string of size 16, padded with '0'
*/
public static String bigIntegerToPaddedHex(final BigInteger dataPathId) {
}
/**
- * @param ofVersion
- * @param portNumber
+ * @param ofVersion OpenFlow version of the switch
+ * @param portNumber port number
* @return true if port number is valid for given protocol version
*/
public static boolean checkPortValidity(final OpenflowVersion ofVersion, final Long portNumber) {
}
/**
- * @param portNumber
+ * @param portNumber port number
* @return string containing number or logical name
*/
public static String portNumberToString(final PortNumberUni portNumber) {
}
/**
- * @param reason
+ * @param reason openflow java packet in reason
* @return corresponding MD-SAL reason class for given OF-API reason
*/
public static Class<? extends PacketInReason> getMdSalPacketInReason(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PacketInReason reason) {
/**
- * @param input
- * @param output
+ * @param input input
+ * @param output output
*/
public RpcInputOutputTuple(IN input, OUT output) {
this.input = input;
}
/**
- * @param e
+ * @param e connection exception
+ * @param <T> rpc result return type
* @return error wrapped inside {@link RpcResult} which is wrapped inside future
*/
public static <T> SettableFuture<RpcResult<T>> getRpcErrorFuture(ConnectionException e) {
}
/**
- * @param session
- * @param cookie
- * @param messageService
+ * @param session switch session context
+ * @param cookie connection distinguisher cookie value
+ * @param messageService message dispatch service instance
* @return barrier response
*/
public static RpcInputOutputTuple<BarrierInput, ListenableFuture<RpcResult<BarrierOutput>>> sendBarrier(SessionContext session,
Code Review / openflowplugin.git / commitdiff