com.h3c.sdn.teamcs

## Interface TeamControllerService

-     public interface TeamControllerService

  Service for getting the data from the local or remote SDN OpenFlow Controller running as a team.

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `dpidIsConnected(DataPathId dpid)`
    `MessageFuture` | `enablePort(DataPathId dpid, BigPortNumber port, boolean enable)` Instructs the controller to enable or disable the given port on the specified datapath.
    `Set<DataPathInfo>` | `getAllDataPathInfo()` Returns information describing each of the OpenFlow datapaths currently connected to the controller or team of controller.
    `Set<DataPathInfo>` | `getAllLocalDataPathInfo()` Returns information describing each of the OpenFlow datapaths currently connected to the controller.
    `DataPathInfo` | `getDataPathInfo(DataPathId dpid)` Returns information describing a specific OpenFlow datapath.
    `DataPathInfo` | `getDpthInfo(DataPathId dpid)`
    `List<MBodyExperimenter>` | `getExperimenter(DataPathId dpid)` Lists meters configured on the datapath.
    `List<MBodyFlowStats>` | `getFlows(DataPathId dpid, TableId tableId)` Returns flows installed in the specified table of the given datapath.
    `List<MBodyGroupDescStats>` | `getGroupDescription(DataPathId dpid)` Returns the groups description on the specified datapath.
    `MBodyGroupDescStats` | `getGroupDescription(DataPathId dpid, GroupId groupId)` Returns the group description on the specified datapath and groupId.
    `MBodyGroupFeatures` | `getGroupFeatures(DataPathId dpid)` Returns the supported group features for the specified datapath.
    `List<MBodyGroupStats>` | `getGroupStats(DataPathId dpid)` Returns the groups statistics on the specified datapath.
    `MBodyGroupStats` | `getGroupStats(DataPathId dpid, GroupId groupId)` Returns the group statistics on the specified datapath and groupId.
    `DataPathInfo` | `getLocalDataPathInfo(DataPathId dpid)`
    `List<MBodyMeterConfig>` | `getMeterConfig(DataPathId dpid)` Lists meters configured on the datapath.
    `MBodyMeterConfig` | `getMeterConfig(DataPathId dpid, MeterId meterId)` Returns the meter configuration for the given meter ID, from the specified datapath.
    `MBodyMeterFeatures` | `getMeterFeatures(DataPathId dpid)` Returns the meter features for the specified datapath.
    `List<MBodyMeterStats>` | `getMeterStats(DataPathId dpid)` Lists meters configured on the datapath.
    `MBodyMeterStats` | `getMeterStats(DataPathId dpid, MeterId meterId)` Returns the meter statistics for the given meter ID, from the specified datapath.
    `Port` | `getPort(DataPathId dpid, BigPortNumber portNumber)` Returns the port description for the given port, from the specified datapath.
    `List<Port>` | `getPorts(DataPathId dpid)` Returns the port description from the specified datapath.
    `List<MBodyPortStats>` | `getPortStats(DataPathId dpid)` Returns the port statistics from the specified datapath.
    `MBodyPortStats` | `getPortStats(DataPathId dpid, BigPortNumber portNumber)` Returns the port statistics for the given port, from the specified datapath.
    `Map<UUID,ControllerStats>` | `getStats()` Returns statistical information about the controller.
    `List<MessageFuture>` | `send(List<OpenflowMessage> msgs, DataPathId dpid)` Instructs the controller to send the specified list of messages (in order) to the specified datapath.
    `MessageFuture` | `send(OpenflowMessage msg, DataPathId dpid)` Instructs the controller to send the specified message to the specified datapath.
    `MessageFuture` | `sendFlowMod(OfmFlowMod flowMod, DataPathId dpid)` Dispatches the OpenFlow FlowMod message to the given datapath via the Flow Tracker.
    `MessageFuture` | `sendGroupMod(OfmGroupMod groupMod, DataPathId dpid)` Sends the given GROUP_MOD message to the specified datapath.
    `MessageFuture` | `sendMeterMod(OfmMeterMod meterMod, DataPathId dpid)` Sends the OpenFlow METER_MOD message to the specified datapath.

- - ### Method Detail

    - #### getAllDataPathInfo

          Set<DataPathInfo> getAllDataPathInfo()

      Returns information describing each of the OpenFlow datapaths currently connected to the controller or team of controller.
      Returns:
        information describing all connected datapaths

    - #### getAllLocalDataPathInfo

          Set<DataPathInfo> getAllLocalDataPathInfo()

      Returns information describing each of the OpenFlow datapaths currently connected to the controller.
      Returns:
        information describing all connected datapaths

    - #### getDataPathInfo

          DataPathInfo getDataPathInfo(DataPathId dpid)

      Returns information describing a specific OpenFlow datapath. This may be null, if no such OpenFlow datapath is currently connected.
      Parameters:
        `dpid` - the datapath id
      Returns:
        information describing the corresponding datapath
      Throws:
        `NullPointerException` - if dpid is null

    - #### getLocalDataPathInfo

          DataPathInfo getLocalDataPathInfo(DataPathId dpid)

    - #### getDpthInfo

          DataPathInfo getDpthInfo(DataPathId dpid)

    - #### dpidIsConnected

          boolean dpidIsConnected(DataPathId dpid)

    - #### send

          MessageFuture send(OpenflowMessage msg,
                           DataPathId dpid)
                             throws OpenflowException

      Instructs the controller to send the specified message to the specified datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `msg` - the OpenFlow message to send
        `dpid` - the OpenFlow datapath to which the message is to be sent
      Returns:
        a list of message futures
      Throws:
        `NullPointerException` - if either parameter is null
        `IllegalArgumentException` - if msg is mutable, or if it is a FlowMod
        `OpenflowException` - if there was a problem encoding or sending the message

    - #### send

          List<MessageFuture> send(List<OpenflowMessage> msgs,
                                 DataPathId dpid)
                                   throws OpenflowException

      Instructs the controller to send the specified list of messages (in order) to the specified datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `msgs` - the OpenFlow messages to send
        `dpid` - the OpenFlow datapath to which the messages are to be sent
      Returns:
        a message future
      Throws:
        `NullPointerException` - if either parameter is null, or if any element in the list is null
        `IllegalArgumentException` - if any message in the list is mutable, or is a FlowMod
        `OpenflowException` - if there was a problem encoding or sending the messages

    - #### getFlows

          List<MBodyFlowStats> getFlows(DataPathId dpid,
                                      TableId tableId)

      Returns flows installed in the specified table of the given datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.

      If the specified table ID is `TableId.ALL` or null, all flows from all tables will be returned. Note that table ID is ignored for OpenFlow 1.0 devices.

      Parameters:
        `dpid` - the datapath from which the flows are requested
        `tableId` - the ID of the flow table
      Returns:
        the list of flow statistics entries
      Throws:
        `NullPointerException` - if dpid is null

    - #### sendFlowMod

          MessageFuture sendFlowMod(OfmFlowMod flowMod,
                                  DataPathId dpid)
                                    throws OpenflowException

      Dispatches the OpenFlow FlowMod message to the given datapath via the Flow Tracker. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.

      Adds the specified flow to the given datapath if the message's `FlowModCommand` is `ADD`. Deletes the specified flow from the given datapath if the message's `FlowModCommand` is `DELETE`.

      Parameters:
        `flowMod` - the FlowMod message to send
        `dpid` - the target datapath
      Returns:
        a message future
      Throws:
        `NullPointerException` - if flowMod or dpid is null
        `IllegalArgumentException` - if the message is mutable
        `OpenflowException` - if there was a problem encoding or sending the message

    - #### getMeterConfig

          List<MBodyMeterConfig> getMeterConfig(DataPathId dpid)

      Lists meters configured on the datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `dpid` - the target datapath
      Returns:
        the list of meter configurations
      Throws:
        `NullPointerException` - if dpid is null

    - #### getMeterConfig

          MBodyMeterConfig getMeterConfig(DataPathId dpid,
                                        MeterId meterId)

      Returns the meter configuration for the given meter ID, from the specified datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `dpid` - the target datapath
        `meterId` - the ID of the meter
      Returns:
        the meter configuration
      Throws:
        `NullPointerException` - if either parameter is null
        `NotFoundException` - if the specified datapath or meter does not exist
        `VersionNotSupportedException` - if datapath is not OpenFlow 1.3 compliant

    - #### getExperimenter

          List<MBodyExperimenter> getExperimenter(DataPathId dpid)

      Lists meters configured on the datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `dpid` - the target datapath
      Returns:
        the list of experimenter configurations
      Throws:
        `NullPointerException` - if dpid is null

    - #### sendMeterMod

          MessageFuture sendMeterMod(OfmMeterMod meterMod,
                                   DataPathId dpid)
                                     throws OpenflowException

      Sends the OpenFlow METER_MOD message to the specified datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.

      Adds the meter to the specified datapath if the message's `command` is `ADD`. Modifies the meter on the specified datapath if the message's `command` is `MODIFY`. Deletes the meter from the specified datapath if the message's `command` is `DELETE`.

      Parameters:
        `meterMod` - OpenFlow METER_MOD message to datapath
        `dpid` - the target datapath
      Returns:
        a message future
      Throws:
        `NullPointerException` - if dpid or groupMod is null
        `OpenflowException` - if there was a problem sending the METER_MOD message
        `IllegalArgumentException` - if meterMod is mutable

    - #### getGroupDescription

          MBodyGroupDescStats getGroupDescription(DataPathId dpid,
                                                GroupId groupId)

      Returns the group description on the specified datapath and groupId. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `dpid` - the target datapath
        `groupId` - the ID of the group
      Returns:
        group description statistics
      Throws:
        `NullPointerException` - if dpid is null
        `VersionNotSupportedException` - if datapath is not OpenFlow 1.3 compliant

    - #### getGroupDescription

          List<MBodyGroupDescStats> getGroupDescription(DataPathId dpid)

      Returns the groups description on the specified datapath.
      Parameters:
        `dpid` - the target datapath
      Returns:
        the list of group description statistics
      Throws:
        `NullPointerException` - if dpid is null
        `VersionNotSupportedException` - if datapath is not OpenFlow 1.3 compliant

    - #### getGroupStats

          MBodyGroupStats getGroupStats(DataPathId dpid,
                                      GroupId groupId)

      Returns the group statistics on the specified datapath and groupId. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `dpid` - the target datapath
        `groupId` - the ID of the group
      Returns:
        group statistics object
      Throws:
        `NullPointerException` - if dpid is null
        `VersionNotSupportedException` - if datapath is not OpenFlow 1.3 compliant

    - #### getGroupStats

          List<MBodyGroupStats> getGroupStats(DataPathId dpid)

      Returns the groups statistics on the specified datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `dpid` - the target datapath
      Returns:
        the list of group statistics
      Throws:
        `NullPointerException` - if dpid is null
        `VersionNotSupportedException` - if datapath is not OpenFlow 1.3 compliant

    - #### sendGroupMod

          MessageFuture sendGroupMod(OfmGroupMod groupMod,
                                   DataPathId dpid)
                                     throws OpenflowException

      Sends the given GROUP_MOD message to the specified datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.

      Adds the group entry to the specified datapath if the message's `command` is `ADD`. Modifies the group entry on the specified datapath if the message's `command` is `MODIFY`. Deletes the group entry from the specified datapath if the message's `command` is `DELETE`.

      Parameters:
        `groupMod` - OpenFlow GROUP_MOD message to datapath
        `dpid` - the target datapath
      Returns:
        a message future
      Throws:
        `NullPointerException` - if dpid or groupMod is null
        `IllegalArgumentException` - if groupMod is mutable
        `OpenflowException` - if there was a problem sending the GROUP_MOD message

    - #### getPorts

          List<Port> getPorts(DataPathId dpid)

      Returns the port description from the specified datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `dpid` - the target datapath
      Returns:
        the list of port statistics
      Throws:
        `NullPointerException` - if dpid is null
        `NotFoundException` - if the specified datapath does not exist

    - #### getPort

          Port getPort(DataPathId dpid,
                     BigPortNumber portNumber)

      Returns the port description for the given port, from the specified datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `dpid` - the target datapath
        `portNumber` - the target port
      Returns:
        the port statistics
      Throws:
        `NullPointerException` - if dpid is null
        `NotFoundException` - if the specified datapath does not exist or the specified port does not exist on the datapath

    - #### getStats

          Map<UUID,ControllerStats> getStats()

      Returns statistical information about the controller.
      Returns:
        statistical information about the controller

    - #### getPortStats

          List<MBodyPortStats> getPortStats(DataPathId dpid)

      Returns the port statistics from the specified datapath.

      Note that this is a synchronous call that blocks until all the port statistics replies have returned from the datapath.

      Parameters:
        `dpid` - the target datapath
      Returns:
        the list of port statistics
      Throws:
        `NullPointerException` - if dpid is null
        `NotFoundException` - if the specified datapath does not exist

    - #### getPortStats

          MBodyPortStats getPortStats(DataPathId dpid,
                                    BigPortNumber portNumber)

      Returns the port statistics for the given port, from the specified datapath.

      Note that this is a synchronous call that blocks until the port statistics reply has returned from the datapath.

      Parameters:
        `dpid` - the target datapath
        `portNumber` - the target port
      Returns:
        the port statistics
      Throws:
        `NullPointerException` - if dpid is null
        `NotFoundException` - if the specified datapath does not exist or the specified port does not exist on the datapath

    - #### getMeterStats

          List<MBodyMeterStats> getMeterStats(DataPathId dpid)

      Lists meters configured on the datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.
      Parameters:
        `dpid` - the target datapath
      Returns:
        the list of meter descriptions
      Throws:
        `NullPointerException` - if dpid is null

    - #### getMeterStats

          MBodyMeterStats getMeterStats(DataPathId dpid,
                                      MeterId meterId)

      Returns the meter statistics for the given meter ID, from the specified datapath. In an HA mode, when two are more controller operating in a team the implementation has to determine which controller manages the given datapath and send the request to appropriate controller.

      Note that this is a synchronous call that blocks until the meter statistics reply has returned from the datapath.

      Parameters:
        `dpid` - the target datapath
        `meterId` - the target meter ID
      Returns:
        the meter statistics
      Throws:
        `NullPointerException` - if either parameter is null
        `NotFoundException` - if the specified datapath or meter does not exist
        `VersionNotSupportedException` - if datapath is not OpenFlow 1.3 compliant

    - #### getGroupFeatures

          MBodyGroupFeatures getGroupFeatures(DataPathId dpid)

      Returns the supported group features for the specified datapath.

      Note that this is a synchronous call that blocks until the group features reply has returned from the datapath.

      Parameters:
        `dpid` - the target datapath
      Returns:
        the group features
      Throws:
        `NullPointerException` - if dpid id null
        `NotFoundException` - if the specified datapath does not exist
        `VersionMismatchException` - if datapath is not OpenFlow 1.3 compliant

    - #### getMeterFeatures

          MBodyMeterFeatures getMeterFeatures(DataPathId dpid)

      Returns the meter features for the specified datapath.

      Note that this is a synchronous call that blocks until the meter features reply has returned from the datapath.

      Parameters:
        `dpid` - the target datapath
      Returns:
        the meter features
      Throws:
        `NullPointerException` - if dpid is null
        `NotFoundException` - if the specified datapath does not exist
        `VersionMismatchException` - if datapath is not OpenFlow 1.3 compliant

    - #### enablePort

          MessageFuture enablePort(DataPathId dpid,
                                 BigPortNumber port,
                                 boolean enable)

      Instructs the controller to enable or disable the given port on the specified datapath. A message future is returned, to allow the caller to discover the outcome of the request once it has been satisfied.
      Parameters:
        `dpid` - the target datapath
        `port` - the target port
        `enable` - true to enable; false to disable
      Returns:
        a message future
      Throws:
        `NullPointerException` - if either parameter is null
        `NotFoundException` - if the specified datapath does not exist or the specified port does not exist on the datapath

Copyright © 2014. All Rights Reserved.