</plugins>
</build>
- <profiles>
- <!-- Turn off doclint on aggregated API javadoc build. -->
- <profile>
- <id>jdk8</id>
- <activation>
- <jdk>[1.8,)</jdk>
- </activation>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <configuration>
- <additionalparam>-Xdoclint:none</additionalparam>
- </configuration>
- </plugin>
- </plugins>
- </build>
- </profile>
- </profiles>
-
<scm>
<connection>scm:git:http://git.opendaylight.org/gerrit/controller.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
/**
* Returns the first byte from the byte array
- * @param byte[] data
* @return byte value
*/
public static byte getByte(byte[] data) {
/**
* Returns the short value for the byte array passed.
* Size of byte array is restricted to Short.SIZE
- * @param byte[] data
* @return short value
*/
public static short getShort(byte[] data) {
/**
* Returns the int value for the byte array passed.
* Size of byte array is restricted to Integer.SIZE
- * @param byte[] data
* @return int - the integer value of byte array
*/
public static int getInt(byte[] data) {
/**
* Returns the long value for the byte array passed.
* Size of byte array is restricted to Long.SIZE
- * @param byte[] data
* @return long - the integer value of byte array
*/
public static long getLong(byte[] data) {
/**
* Returns the short value for the last numBits of the byte array passed.
* Size of numBits is restricted to Short.SIZE
- * @param byte[] data
- * @param int - numBits
* @return short - the short value of byte array
*/
public static short getShort(byte[] data, int numBits) {
/**
* Returns the int value for the last numBits of the byte array passed.
* Size of numBits is restricted to Integer.SIZE
- * @param byte[] data
- * @param int - numBits
* @return int - the integer value of byte array
*/
public static int getInt(byte[] data, int numBits) {
/**
* Returns the long value for the last numBits of the byte array passed.
* Size of numBits is restricted to Long.SIZE
- * @param byte[] data
- * @param int - numBits
* @return long - the integer value of byte array
*/
public static long getLong(byte[] data, int numBits) {
* 0101000010 | 0000101 | 1111001010010101011
* will be returned as {0,0,0,0,0,1,0,1}
*
- * @param byte[] data
- * @param int startOffset - offset to start fetching bits from data from
- * @param int numBits - number of bits to be fetched from data
+ * @param startOffset - offset to start fetching bits from data from
+ * @param numBits - number of bits to be fetched from data
* @return byte [] - LSB aligned bits
*
* @throws BufferException
/**
* Bits are expected to be stored in the input byte array from LSB
- * @param byte[] - data to set the input byte
- * @param byte - input byte to be inserted
- * @param startOffset - offset of data[] to start inserting byte from
- * @param numBits - number of bits of input to be inserted into data[]
+ * @param data to set the input byte
+ * @param input byte to be inserted
+ * @param startOffset offset of data[] to start inserting byte from
+ * @param numBits number of bits of input to be inserted into data[]
*
* @throws BufferException
* when the input, startOffset and numBits are not congruent
/**
* Bits are expected to be stored in the input byte array from LSB
- * @param byte[] - data to set the input byte
- * @param byte[] - input bytes to be inserted
- * @param startOffset - offset of data[] to start inserting byte from
- * @param numBits - number of bits of input to be inserted into data[]
- * @return void
+ * @param data to set the input byte
+ * @param input bytes to be inserted
+ * @param startOffset offset of data[] to start inserting byte from
+ * @param numBits number of bits of input to be inserted into data[]
* @throws BufferException
* when the startOffset and numBits parameters are not congruent
* with data and input buffers' size
/**
* Returns numBits 1's in the MSB position
- *
- * @param numBits
- * @return
*/
public static int getMSBMask(int numBits) {
int mask = 0;
/**
* Returns numBits 1's in the LSB position
- *
- * @param numBits
- * @return
*/
public static int getLSBMask(int numBits) {
int mask = 0;
/**
* Returns the numerical value of the byte array passed
*
- * @param byte[] - array
* @return long - numerical value of byte array passed
*/
static public long toNumber(byte[] array) {
* Returns the numerical value of the last numBits (LSB bits) of the byte
* array passed
*
- * @param byte[] - array
- * @param int - numBits
* @return long - numerical value of byte array passed
*/
static public long toNumber(byte[] array, int numBits) {
* Accepts a number as input and returns its value in byte form in LSB
* aligned form example: input = 5000 [1001110001000] bytes = 19, -120
* [00010011] [10001000]
- *
- * @param Number
- * @return byte[]
- *
*/
-
public static byte[] toByteArray(Number input) {
Class<? extends Number> dataType = input.getClass();
short size = 0;
* aligned form example: input = 5000 [1001110001000] bytes = -114, 64
* [10011100] [01000000]
*
- * @param Number
- * input
- * @param int numBits - the number of bits to be returned
+ * @param numBits - the number of bits to be returned
* @return byte[]
*
*/
/**
* Takes an LSB aligned byte array and returned the LSB numBits in a MSB
- * aligned byte array
- *
- * @param inputbytes
- * @param numBits
- * @return
- */
- /**
+ * aligned byte array.
+ * <p>
* It aligns the last numBits bits to the head of the byte array following
* them with numBits % 8 zero bits.
*
* Example: For inputbytes = [00000111][01110001] and numBits = 12 it
* returns: shiftedBytes = [01110111][00010000]
*
- * @param byte[] inputBytes
- * @param int numBits - number of bits to be left aligned
+ * @param numBits - number of bits to be left aligned
* @return byte[]
*/
public static byte[] shiftBitsToMSB(byte[] inputBytes, int numBits) {
* Example: For inputbytes = [01110111][00010000] and numBits = 12 it
* returns: shiftedBytes = [00000111][01110001]
*
- * @param byte[] inputBytes
- * @param int numBits - number of bits to be right aligned
+ * @param inputBytes
+ * @param numBits - number of bits to be right aligned
* @return byte[]
*/
public static byte[] shiftBitsToLSB(byte[] inputBytes, int numBits) {
* Insert in the data buffer at position dictated by the offset the number
* of bits specified from the input data byte array. The input byte array
* has the bits stored starting from the LSB
- *
- * @param byte[] data
- * @param byte[] inputdata
- * @param int startOffset
- * @param int numBits
*/
public static void insertBits(byte[] data, byte[] inputdataLSB,
int startOffset, int numBits) {
/**
* Checks for overflow and underflow exceptions
- * @param data
- * @param startOffset
- * @param numBits
- * @throws PacketException when the startOffset and numBits parameters
+ * @throws BufferException when the startOffset and numBits parameters
* are not congruent with the data buffer's size
*/
public static void checkExceptions(byte[] data, int startOffset, int numBits)
*
* @param name Create a new DataLink, not for general use but
* available only for sub classes
- *
- * @return constructed object
*/
protected DataLinkAddress(String name) {
this.name = name;
/**
* Sets the destination MAC address for the current Ethernet object instance
- * @param byte[] - the destinationMACAddress to set
+ * @param destinationMACAddress the destinationMACAddress to set
*/
public Ethernet setDestinationMACAddress(byte[] destinationMACAddress) {
fieldValues.put(DMAC, destinationMACAddress);
/**
* Sets the source MAC address for the current Ethernet object instance
- * @param byte[] - the sourceMACAddress to set
+ * @param sourceMACAddress the sourceMACAddress to set
*/
public Ethernet setSourceMACAddress(byte[] sourceMACAddress) {
fieldValues.put(SMAC, sourceMACAddress);
/**
* Sets the etherType for the current Ethernet object instance
- * @param short - the etherType to set
+ * @param etherType the etherType to set
*/
public Ethernet setEtherType(short etherType) {
byte[] ethType = BitBufferHelper.toByteArray(etherType);
*
* @param macAddress A byte array in big endian format
* representing the Ethernet MAC Address
- *
- * @return The constructed object if valid
*/
public EthernetAddress(byte[] macAddress) throws ConstructionException {
super(addressName);
}
/**
- * @param String
+ * @param type
* - description of the type of TLV
* @return LLDPTLV - full TLV
*/
}
/**
- * @param String
+ * @param type
* - description of the type of TLV
- * @param LLDPTLV
+ * @param tlv
* - tlv to set
- * @return void
*/
public void setTLV(String type, LLDPTLV tlv) {
putToTLVs(getType(type), tlv);
}
/**
- * @param LLDPTLV
+ * @param chassisId
* - the chassisId to set
*/
public LLDP setChassisId(LLDPTLV chassisId) {
}
/**
- * @param LLDPTLV
- * - the chassisId to set
+ * @param systemNameId
+ * - the systemNameId to set
*/
public LLDP setSystemNameId(LLDPTLV systemNameId) {
setTLV(SYSTEMNAMEID, systemNameId);
}
/**
- * @param LLDPTLV
+ * @param portId
* - the portId to set
* @return LLDP
*/
}
/**
- * @param LLDPTLV
+ * @param ttl
* - the ttl to set
* @return LLDP
*/
}
/**
- * @param customTLVList
+ * @param customTLV
* the list of custom TLVs to set
* @return this LLDP
*/
}
/**
- * @param byte - the type to set
+ * @param type the type to set
* @return LLDPTLV
*/
public LLDPTLV setType(byte type) {
}
/**
- * @param short - the length to set
+ * @param length the length to set
* @return LLDPTLV
*/
public LLDPTLV setLength(short length) {
}
/**
- * @param byte[] - the value to set
+ * @param value the value to set
* @return LLDPTLV
*/
public LLDPTLV setValue(byte[] value) {
/**
* Creates the custom TLV value including OUI, subtype and custom string
*
- * @param portId
+ * @param customString
* port identifier string
* @return the custom TLV value in byte array
- * @see {@link #createCustomTLVValue(byte,String)}
+ * @see #createCustomTLVValue(byte[],byte[])
*/
static public byte[] createCustomTLVValue(String customString) {
byte[] customByteArray = customString.getBytes(Charset.defaultCharset());
/**
* Creates the custom TLV value including OUI, subtype and custom string
* @param subtype openflow subtype
- * @param portId
+ * @param customByteArray
* port identifier string
* @return the custom TLV value in byte array
*/
* This method deserializes the data bits obtained from the wire into the
* respective header and payload which are of type Packet
*
- * @param byte[] data - data from wire to deserialize
- * @param int bitOffset bit position where packet header starts in data
+ * @param data - data from wire to deserialize
+ * @param bitOffset bit position where packet header starts in data
* array
- * @param int size of packet in bits
+ * @param size size of packet in bits
* @return Packet
* @throws PacketException
*/
* normal Packet.serialize() path. An example is the checksum computation
* for IPv4
*
- * @param byte[] - serialized bytes
+ * @param myBytes serialized bytes
* @throws PacketException
*/
protected void postSerializeCustomOperation(byte[] myBytes)
* Currently only IPv4 and ICMP do checksum computation and validation. TCP
* and UDP need to implement these if required.
*
- * @param byte[] data The byte stream representing the Ethernet frame
- * @param int startBitOffset The bit offset from where the byte array corresponding to this Packet starts in the frame
+ * @param data The byte stream representing the Ethernet frame
+ * @param startBitOffset The bit offset from where the byte array corresponding to this Packet starts in the frame
* @throws PacketException
*/
protected void postDeserializeCustomOperation(byte[] data, int startBitOffset)
* 'fieldname'. The offset is present in the hdrFieldCoordMap of the
* respective packet class
*
- * @param String
- * fieldName
* @return Integer - startOffset of the requested field
*/
public int getfieldOffset(String fieldName) {
* 'fieldname'. The numBits are present in the hdrFieldCoordMap of the
* respective packet class
*
- * @param String
- * fieldName
* @return Integer - number of bits of the requested field
*/
public int getfieldnumBits(String fieldName) {
</plugins>
</build>
- <profiles>
- <!-- Turn off doclint. -->
- <profile>
- <id>jdk8</id>
- <activation>
- <jdk>[1.8,)</jdk>
- </activation>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <configuration>
- <additionalparam>-Xdoclint:none</additionalparam>
- </configuration>
- </plugin>
- </plugins>
- </build>
- </profile>
- </profiles>
-
<scm>
<connection>scm:git:http://git.opendaylight.org/gerrit/controller.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
* Creates a client.
*
* @param address remote address
- * @param connectStrategy Reconnection strategy to be used when initial connection fails
+ * @param strategy Reconnection strategy to be used when initial connection fails
*
* @return Future representing the connection process. Its result represents the combined success of TCP connection
* as well as session negotiation.
}
/**
- * @deprecated Should only be used with {@link AbstractDispatcher#AbstractDispatcher()}
+ * @deprecated Should only be used with AbstractDispatcher#AbstractDispatcher()
*/
@Deprecated
@Override
* needing to provide only
*
* @param <M> Protocol message type
- * @param <S> Protocol session type, has to extend ProtocolSession<M>
+ * @param <S> Protocol session type, has to extend {@code ProtocolSession<M>}
*/
@Deprecated
public abstract class AbstractSessionNegotiator<M, S extends AbstractProtocolSession<?>> extends ChannelInboundHandlerAdapter implements SessionNegotiator<S> {
/**
* Fired when the session was established successfully.
*
- * @param remoteParams Peer address families which we accepted
+ * @param session New session
*/
void onSessionUp(S session);
*
* Initial sleep time is specified as minSleep. Each subsequent unsuccessful attempt multiplies this time by a constant
* factor (sleepFactor) -- this allows for either constant reconnect times (sleepFactor = 1), or various degrees of
- * exponential back-off (sleepFactor > 1). Maximum sleep time between attempts can be capped to a specific value
+ * exponential back-off (sleepFactor > 1). Maximum sleep time between attempts can be capped to a specific value
* (maxSleep).
*
* The strategy can optionally give up based on two criteria:
</plugin>
</plugins>
</build>
-
- <profiles>
- <!-- Turn off doclint on aggregated API javadoc build. -->
- <profile>
- <id>jdk8</id>
- <activation>
- <jdk>[1.8,)</jdk>
- </activation>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <configuration>
- <additionalparam>-Xdoclint:none</additionalparam>
- </configuration>
- </plugin>
- </plugins>
- </build>
- </profile>
- </profiles>
</project>
/**
* Opens new configuration transaction.
*
- * @return {@link ObjectName} of {@link ConfigTransactionControllerMXBean}
+ * @return {@link ObjectName} of
+ * {@link org.opendaylight.controller.config.api.jmx.ConfigTransactionControllerMXBean}
*/
ObjectName beginConfig();
*
* @param transactionControllerON
* {@link ObjectName} of
- * {@link ConfigTransactionControllerMXBean} that was received in
- * {@link #beginConfig()} method call.
+ * {@link org.opendaylight.controller.config.api.jmx.ConfigTransactionControllerMXBean} that was
+ * received in {@link #beginConfig()} method call.
* @return CommitStatus
* @throws ValidationException
* if validation fails
/**
* Configuration framework will call this setter on all modules implementing
* this interface. It is responsibility of modules or rather their instances
- * to close registrator in their {@link Closeable#close()} method. Same
+ * to close registrator in their {@link java.io.Closeable#close()} method. Same
* module will get the same registrator during reconfiguration.
*
* @param rootRuntimeBeanRegistrator
/**
* Remove service reference.
- * @return true iif removed
* @throws IllegalArgumentException if service interface name is not advertised by any module
*/
void removeServiceReference(String serviceInterfaceName, String refName) throws InstanceNotFoundException;
* of a module. This annotation must be present for each dependency setter in
* {@link org.opendaylight.controller.config.spi.Module} M(X)Bean interface.
* Together with name of dependent bean the {@link #value()} will be used to get
- * {@link ObjectName} of dependency.
+ * {@link javax.management.ObjectName} of dependency.
*
* <p>
* Example:<br>
*
* <code>
- *
- * @RequireInterface(value = ThreadPoolServiceInterface.class, optional =
- * false)<br/> void setThreadPool(ObjectName on);
- * </code>
+ * {@literal @}RequireInterface(value = ThreadPoolServiceInterface.class, optional = false)<br>
+ * void setThreadPool(ObjectName on);
+ * </code>
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
/**
* Those are executed by Jolokia clients on configuration transaction
- * represented by {@link ConfigMBeanServer} instance. Note: Reason for having
+ * represented by <code>ConfigMBeanServer</code> instance. Note: Reason for having
* methods in super interface is that JMX allows only one MXBean to be
* implemented and implementations can expose additional methods to be exported. <br>
* Implementation of {@link ConfigTransactionController} is not required to
* Creates notification about successful commit execution.
*
* Intended for config-persister.
- *
- * @param transactionName
- * @param cfgSnapshot
*/
public static CommitJMXNotification afterCommit(NotificationBroadcasterSupport source, String messages) {
return new CommitJMXNotification(source, messages);
/**
* Base implementation of Module. This implementation contains base logic for Module reconfiguration with associated fields.
- * @param <M> Type of module implementation. Enables easier implementation for the {@link #isSame} method
+ * @param <M> Type of module implementation. Enables easier implementation for the <code>isSame()</code> method
*/
public abstract class AbstractModule<M extends AbstractModule<M>> implements org.opendaylight.controller.config.spi.Module {
import org.osgi.framework.BundleContext;
/**
- * Factory which creates {@link Module instances. An instance of this interface
+ * Factory which creates {@link Module} instances. An instance of this interface
* needs to be exported into the OSGi Service Registry. Such an instance
* provides metadata describing services which can be published from it.
*
- * Each {@link Module } can optionally be instantiated with a
- * {@link DynamicMBean} which represents the configuration of the currently
+ * Each {@link Module} can optionally be instantiated with a
+ * {@link javax.management.DynamicMBean} which represents the configuration of the currently
* running instance.
*/
public interface ModuleFactory {
* Create a new Module instance. The returned object is expected to use the
* dependencyResolver provided when resolving ObjectNames to actual Module
* instances. A reference to an abstract view of the previous configuration
- * is also provided in the form of a {@link DynamicMBean}. Implementations
+ * is also provided in the form of a {@link javax.management.DynamicMBean}. Implementations
* should use the MBeanInfo interface to understand the structure of the
* configuration information.
*
* @param old
* existing module from platform MBeanServer that is being
* reconfigured. Implementations should inspect its attributes
- * using {@link DynamicMBean#getAttribute(String)} and set those
+ * using {@link javax.management.DynamicMBean#getAttribute(String)} and set those
* attributes on newly created module. If reconfiguration of live
* instances is supported, this live instance can be retreived
* using
/**
* Config subsystem facade for xml format
- * <p/>
+ * <p>
* TODO extract generic interface for config subsystem facades
*/
public class ConfigSubsystemFacade implements Closeable {
private final AttributeReadingStrategy innerStrategy;
- /**
- * @param attributeIfc
- * @param innerStrategy
- */
public ArrayAttributeReadingStrategy(String nullableDefault, AttributeReadingStrategy innerStrategy) {
super(nullableDefault);
this.innerStrategy = innerStrategy;
}
/**
- * return a map containing namespace -> moduleName -> instanceName map. Attribute parsing is omitted.
+ * return a map containing namespace -> moduleName -> instanceName map. Attribute parsing is omitted.
*/
public Map<String, Multimap<String, ModuleElementDefinition>> fromXmlModulesMap(XmlElement xml,
EditStrategyType defaultEditStrategyType, ServiceRegistryWrapper serviceTracker) throws DocumentedException {
* of {@link org.opendaylight.controller.config.spi.Module#validate()} and
* {@link org.opendaylight.controller.config.spi.Module#getInstance()} is also
* guaranteed by
- * {@link org.opendaylight.controller.config.manager.impl.ConfigTransactionControllerInternal}
+ * org.opendaylight.controller.config.manager.impl.ConfigTransactionControllerInternal
* so the actual {@link org.opendaylight.controller.config.spi.Module} needs not
* to be thread safe.
* </p>
import org.osgi.framework.BundleContext;
/**
- * {@link org.opendaylight.controller.config.manager.impl.ConfigTransactionControllerImpl}
+ * org.opendaylight.controller.config.manager.impl.ConfigTransactionControllerImpl
* receives list of factories using this interface. For testing, this could be
* implemented as hard coded list of objects, for OSGi this would look for all
* services in OSGi Service Registry are registered under
/**
* This subclass is used for registering readable module into JMX, it is also
- * used as underlying provider in {@link RuntimeBeanRegistratorImpl}. Closing
+ * used as underlying provider in RuntimeBeanRegistratorImpl. Closing
* the instance thus unregisters all JMX beans related to the module excluding
* currently open transactions.
*/
*
* Primary customizer may return tracking object,
* which will be passed to it during invocation of
- * {@link BundleTrackerCustomizer#removedBundle(Bundle, BundleEvent, Future)}
+ * {@link BundleTrackerCustomizer#removedBundle(Bundle, BundleEvent, Object)}
*
*
* This extender modifies behaviour to not leak platform thread
<module>yang-jmx-generator-it</module>
</modules>
</profile>
- <!-- Turn off doclint. -->
- <profile>
- <id>jdk8</id>
- <activation>
- <jdk>[1.8,)</jdk>
- </activation>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <configuration>
- <additionalparam>-Xdoclint:none</additionalparam>
- </configuration>
- </plugin>
- </plugins>
- </build>
- </profile>
</profiles>
</project>
* </pre>
*
* </blockquote>
- * </p>
*/
public class ModuleMXBeanEntry extends AbstractEntry {
import org.opendaylight.yangtools.yang.model.api.Module;
/**
- * Maps from module namespaces to java package names using a Map<String,
- * String>, where key is namespace prefix and value is package that replaces
- * matched prefix.
+ * Maps from module namespaces to java package names using a Map<String, String>,
+ * where key is namespace prefix and value is package that replaces matched prefix.
*/
public class PackageTranslator {
private final Map<String, String> namespacePrefixToPackageMap;
* </pre>
*
* </blockquote>
- * </p>
*/
public class ServiceInterfaceEntry extends AbstractEntry {
private static final Logger LOG = LoggerFactory
*
* @return Yang name converted to cammel case, starting with a capital
* letter. For details see
- * {@link ModuleMXBeanEntry#findJavaNamePrefix(org.opendaylight.yangtools.yang.model.api.SchemaNode)}
+ * {@link org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry#getJavaNamePrefix()}
*/
@Override
public String getUpperCaseCammelCase() {
</dependency>
</dependencies>
- <profiles>
- <!-- Turn off doclint. -->
- <profile>
- <id>jdk8</id>
- <activation>
- <jdk>[1.8,)</jdk>
- </activation>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <configuration>
- <additionalparam>-Xdoclint:none</additionalparam>
- </configuration>
- </plugin>
- </plugins>
- </build>
- </profile>
- </profiles>
-
<scm>
<connection>scm:git:http://git.opendaylight.org/gerrit/controller.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
/**
* Event source is a node in topology which is able to produces notifications.
- * To register event source you use {@link EventSourceRegistry#registerEventSource(EventSource)()}.
+ * To register event source you use {@link EventSourceRegistry#registerEventSource(EventSource)}.
* EventSourceRegistry will request registered event source to publish notifications
* whenever EventSourceRegistry has been asked to publish a certain type of notifications.
* EventSourceRegistry will call method JoinTopic to request EventSource to publish notification.
*/
List<SchemaPath> getAvailableNotifications();
-}
\ No newline at end of file
+}
package org.opendaylight.controller.messagebus.spi;
/**
- *EventSourceRegistry is used to register {@link EventSource}.
- *
+ * EventSourceRegistry is used to register {@link EventSource}.
*/
public interface EventSourceRegistry extends AutoCloseable {
/**
* Registers the given EventSource for public consumption. The EventSource is
- * associated with the node identified via {@linkEventSource#getSourceNodeKey}.
+ * associated with the node identified via {@link EventSource#getSourceNodeKey}.
*
* @param eventSource the EventSource instance to register
- * @return an EventSourceRegistration instance that is used to unregister the EventSource via {@link EventSourceRegistrationImpl#close()}.
+ * @return an EventSourceRegistration instance that is used to unregister the EventSource via {@link EventSourceRegistration#close()}.
*/
<T extends EventSource> EventSourceRegistration<T> registerEventSource(T eventSource);
-}
\ No newline at end of file
+}
* Method filters qnames based on wildcard strings
*
* @param list
- * @param patterh matching pattern
+ * @param pattern matching pattern
* @return list of filtered qnames
*/
public static List<SchemaPath> expandQname(final List<SchemaPath> list, final Pattern pattern) {
<module>benchmark-data-store</module>
</modules>
</profile>
- <!-- Turn off doclint. -->
- <profile>
- <id>jdk8</id>
- <activation>
- <jdk>[1.8,)</jdk>
- </activation>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <configuration>
- <additionalparam>-Xdoclint:none</additionalparam>
- </configuration>
- </plugin>
- </plugins>
- </build>
- </profile>
</profiles>
</project>
/**
* This is a sample implementation of a Role Change Listener which is an actor, which registers itself to the ClusterRoleChangeNotifier
- * <p/>
+ * <p>
* The Role Change listener receives a SetNotifiers message with the notifiers to register itself with.
- * <p/>
+ * <p>
* It kicks of a scheduler which sents registration messages to the notifiers, till it gets a RegisterRoleChangeListenerReply
- * <p/>
+ * <p>
* If all the notifiers have been regsitered with, then it cancels the scheduler.
* It starts the scheduler again when it receives a new registration
*
/**
* Configuration Parameter interface for configuring the Raft consensus system
- * <p/>
+ *
+ * <p>
* Any component using this implementation might want to provide an implementation of
* this interface to configure
- * <p/>
+ *
+ * <p>
* A default implementation will be used if none is provided.
*
* @author Kamal Rameshan
/**
* The interval at which a heart beat message will be sent to the remote
* RaftActor.
- * <p/>
+ *
+ * <p>
* Since this is set to 100 milliseconds the Election timeout should be
* at least 200 milliseconds
*/
/**
* ElectionTerm contains information about a RaftActors election term.
- * <p/>
+ *
+ * <p>
* This information includes the last known current term of the RaftActor
* and which candidate was voted for by the RaftActor in that term.
- * <p/>
+ *
+ * <p>
* This class ensures that election term information is persisted.
*/
public interface ElectionTerm {
* in a cluster. It implements the RAFT algorithm as described in the paper
* <a href='https://ramcloud.stanford.edu/wiki/download/attachments/11370504/raft.pdf'>
* In Search of an Understandable Consensus Algorithm</a>
- * <p/>
+ *
+ * <p>
* RaftActor has 3 states and each state has a certain behavior associated
* with it. A Raft actor can behave as,
* <ul>
* <li> A Follower (or) </li>
* <li> A Candidate </li>
* </ul>
- * <p/>
- * <p/>
+ *
+ * <p>
* A RaftActor MUST be a Leader in order to accept requests from clients to
* change the state of it's encapsulated state machine. Once a RaftActor becomes
* a Leader it is also responsible for ensuring that all followers ultimately
* have the same log and therefore the same state machine as itself.
- * <p/>
- * <p/>
+ *
+ * <p>
* The current behavior of a RaftActor determines how election for leadership
* is initiated and how peer RaftActors react to request for votes.
- * <p/>
- * <p/>
+ *
+ * <p>
* Each RaftActor also needs to know the current election term. It uses this
* information for a couple of things. One is to simply figure out who it
* voted for in the last election. Another is to figure out if the message
* it received to update it's state is stale.
- * <p/>
- * <p/>
+ *
+ * <p>
* The RaftActor uses akka-persistence to store it's replicated log.
* Furthermore through it's behaviors a Raft Actor determines
- * <p/>
* <ul>
* <li> when a log entry should be persisted </li>
* <li> when a log entry should be applied to the state machine (and) </li>
/**
* A raft actor support class that participates in leadership transfer. An instance is created upon
* initialization of leadership transfer.
- * <p/>
+ *
+ * <p>
* The transfer process is as follows:
* <ol>
* <li>Send a LeaderStateChanged message with a null leader Id to the local RoleChangeNotifier to notify
* their local RoleChangeNotifiers.</li>
* <li>Call {@link RaftActor#pauseLeader} passing this RaftActorLeadershipTransferCohort
* instance. This allows derived classes to perform work prior to transferring leadership.</li>
- * <li>When the pause is complete, the {@link #run} method is called which in turn calls
- * {@link Leader#transferLeadership}.</li>
+ * <li>When the pause is complete, the run method is called which in turn calls
+ * {@link Leader#transferLeadership(RaftActorLeadershipTransferCohort)}.</li>
* <li>The Leader calls {@link #transferComplete} on successful completion.</li>
* <li>Wait a short period of time for the new leader to be elected to give the derived class a chance to
* possibly complete work that was suspended while we were transferring.</li>
* <li>On notification of the new leader from the RaftActor or on time out, notify {@link OnComplete} callbacks.</li>
* </ol>
- * <p/>
+ *
+ * <p>
* NOTE: All methods on this class must be called on the actor's thread dispatcher as they may access/modify
* internal state.
*
/**
* Removes entries from the in-memory log and the persisted log starting at the given index.
- * <p/>
+ *
+ * <p>
* The persisted information would then be used during recovery to properly
* reconstruct the state of the in-memory replicated log
*
/**
* The behavior of a RaftActor when it is in the Leader state
- * <p/>
+ *
+ * <p>
* Leaders:
* <ul>
* <li> Upon election: send initial empty AppendEntries RPCs
* follower (§5.3)
* <li> If AppendEntries fails because of log inconsistency:
* decrement nextIndex and retry (§5.3)
- * <li> If there exists an N such that N > commitIndex, a majority
+ * <li> If there exists an N such that N > commitIndex, a majority
* of matchIndex[i] ≥ N, and log[N].term == currentTerm:
* set commitIndex = N (§5.3, §5.4).
* </ul>
/**
* Initiates a snapshot capture to install on a follower.
- * <p/>
+ *
+ * <p>
* Install Snapshot works as follows
* 1. Leader initiates the capture snapshot by calling createSnapshot on the RaftActor.
* 2. On receipt of the CaptureSnapshotReply message, the RaftActor persists the snapshot and makes a call to
/**
* The behavior of a RaftActor when it is in the Candidate raft state.
- * <p/>
+ *
+ * <p>
* Candidates (§5.2):
* <ul>
* <li> On conversion to candidate, start election:
/**
* The behavior of a RaftActor in the Follower raft state.
- * <p/>
* <ul>
* <li> Respond to RPCs from candidates and leaders
* <li> If election timeout elapses without receiving AppendEntries
/**
* Leader which is termed as isolated.
- * <p/>
+ *
+ * <p>
* If the reply from the majority of the followers is not received then the leader changes its behavior
* to IsolatedLeader. An isolated leader may have followers and they would continue to receive replicated messages.
- * <p/>
+ *
+ * <p>
* A schedule is run, at an interval of (10 * Heartbeat-time-interval), in the Leader
* to check if its isolated or not.
- * <p/>
+ *
+ * <p>
* In the Isolated Leader , on every AppendEntriesReply, we aggressively check if the leader is isolated.
* If no, then the state is switched back to Leader.
- *
*/
public class IsolatedLeader extends AbstractLeader {
IsolatedLeader(RaftActorContext context, @Nullable AbstractLeader initializeFromLeader) {
/**
* The behavior of a RaftActor when it is in the Leader state.
- * <p/>
+ *
+ * <p>
* Leaders:
* <ul>
* <li> Upon election: send initial empty AppendEntries RPCs
* follower (§5.3)
* <li> If AppendEntries fails because of log inconsistency:
* decrement nextIndex and retry (§5.3)
- * <li> If there exists an N such that N > commitIndex, a majority
+ * <li> If there exists an N such that N > commitIndex, a majority
* of matchIndex[i] ≥ N, and log[N].term == currentTerm:
* set commitIndex = N (§5.3, §5.4).
* </ul>
* <li>Start a timer (Stopwatch).</li>
* <li>Send an initial AppendEntries heartbeat to all followers.</li>
* <li>On AppendEntriesReply, check if the follower's new match Index matches the leader's last index</li>
- * <li>If it matches, </li>
+ * <li>If it matches,
* <ul>
* <li>Send an additional AppendEntries to ensure the follower has applied all its log entries to its state.</li>
* <li>Send an ElectionTimeout to the follower to immediately start an election.</li>
* <li>Notify {@link RaftActorLeadershipTransferCohort#transferComplete}.</li>
- * </ul>
+ * </ul></li>
* <li>Otherwise if the election time out period elapses, notify
- * {@link RaftActorLeadershipTransferCohort#abortTtransfer}.</li>
+ * {@link RaftActorLeadershipTransferCohort#abortTransfer}.</li>
* </ul>
*
* @param leadershipTransferCohort the cohort participating in the leadership transfer
* the log with the leader's current term. Once the no-op entry is committed, all prior entries are committed
* indirectly. Once all entries are committed, ie commitIndex matches the last log index, it switches to the
* normal Leader state.
- * <p/>
+ *
+ * <p>
* The use of a no-op entry in this manner is outlined in the last paragraph in §8 of the
* <a href="https://raft.github.io/raft.pdf">extended raft version</a>.
*
* Request to locate the leader raft actor. Each {@link org.opendaylight.controller.cluster.raft.RaftActor} must
* respond with a {@link FindLeaderReply} containing the address of the leader, as it is known to that particular
* actor.
- * <p/>
+ *
+ * <p>
* This message is intended for testing purposes only.
*/
@VisibleForTesting
* Reply to {@link FindLeader} message, containing the address of the leader actor, as known to the raft actor which
* sent the message. If the responding actor does not have knowledge of the leader, {@link #getLeaderActor()} will
* return {@link Optional#empty()}.
- * <p/>
+ *
+ * <p>
* This message is intended for testing purposes only.
*/
@VisibleForTesting
* we may want to be able to determine which Raft replica should become the leader - with Raft elections are
* randomized so it is not possible to specify which replica should be the leader. The ability to specify
* the leader would be quite useful when testing a raft cluster.
- * <p/>
+ *
+ * <p>
* Similarly we may want to customize when exactly we apply a modification to the state - with Raft a modification
* is only applied to the state when the modification is replicated to a majority of the replicas. The ability to
* apply a modification to the state before consensus would be useful in scenarios where you have only 2 nodes
* in a Raft cluster and one of them is down but you still want the RaftActor to apply a modification to the state.
- *
*/
public interface RaftPolicy {
/**
<tag>HEAD</tag>
<url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:MD-SAL</url>
</scm>
-
- <profiles>
- <!-- Turn off doclint on aggregated API javadoc build. -->
- <profile>
- <id>jdk8</id>
- <activation>
- <jdk>[1.8,)</jdk>
- </activation>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <configuration>
- <additionalparam>-Xdoclint:none</additionalparam>
- </configuration>
- </plugin>
- </plugins>
- </build>
- </profile>
- </profiles>
</project>
* to data change notifications on any node of clustered datastore. DataChangeListener enables data change notifications
* only at leader of the datastore shard.</p>
*
- * @Deprecated Replaced by {@link ClusteredDataTreeChangeListener}
+ * @deprecated Replaced by {@link ClusteredDataTreeChangeListener}
*/
@Deprecated
-public interface ClusteredDataChangeListener extends DataChangeListener{
+public interface ClusteredDataChangeListener extends DataChangeListener {
}
* Returns before-state of top level container. Implementations are encouraged,
* but not required to provide this state.
*
- * @param root Class representing data container
* @return State of object before modification. Null if subtree was not present,
* or the implementation cannot provide the state.
*/
/**
* Returns after-state of top level container.
*
- * @param root Class representing data container
* @return State of object after modification. Null if subtree is not present.
*/
@Nullable T getDataAfter();
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
- * A {@link DOMService} which allows users to register for changes to a
+ * A {@link BindingService} which allows users to register for changes to a
* subtree.
*/
public interface DataTreeChangeService extends BindingService {
* delivery of change events.
*/
@Nonnull <T extends DataObject,L extends DataTreeChangeListener<T>> ListenerRegistration<L> registerDataTreeChangeListener(@Nonnull DataTreeIdentifier<T> treeId, @Nonnull L listener);
-}
\ No newline at end of file
+}
}
/**
- * Return the {@link YangInstanceIdentifier} of the root node.
+ * Return the {@link InstanceIdentifier} of the root node.
*
* @return Instance identifier corresponding to the root node.
*/
return getClass().getSimpleName() + "{datastoreType = " + datastoreType + ", rootIdentifier = " +
rootIdentifier + "}";
}
-}
\ No newline at end of file
+}
* @param notification
* the notification to publish.
* @return A listenable future which will report completion when the service has finished
- * propagating the notification to its immediate registrants, or {@value #REJECTED} if resource
+ * propagating the notification to its immediate registrants, or {@link #REJECTED} if resource
* constraints prevent
* @throws NullPointerException if the notification is null
*/
* @param unit a TimeUnit determining how to interpret the
* timeout parameter
* @return A listenable future which will report completion when the service has finished
- * propagating the notification to its immediate registrants, or {@value #REJECTED} if resource
+ * propagating the notification to its immediate registrants, or {@link #REJECTED} if resource
* constraints prevent
* @throws InterruptedException if interrupted while waiting
* @throws NullPointerException if the notification or unit is null
* are registered using {@link #registerNotificationListener(org.opendaylight.yangtools.yang.binding.NotificationListener)}
* method.
*
- * <h5>Dispatch Listener Example</h5>
+ * <h3>Dispatch Listener Example</h3>
* <p>
* Lets assume we have following YANG model:
*
* </pre>
*
* The generated interface will be:
- * <pre>
+ * {@code
* public interface ExampleListener extends NotificationListener {
* void onStart(Start notification);
* void onStop(Stop notification);
* }
- * </pre>
+ * }
* The following defines an implementation of the generated interface:
- * <pre>
+ * {@code
* public class MyExampleListener implements ExampleListener {
* public void onStart(Start notification) {
* // do something
* // do something
* }
* }
- * </pre>
+ * }
* The implementation is registered as follows:
- * <pre>
+ * {@code
* MyExampleListener listener = new MyExampleListener();
* ListenerRegistration<NotificationListener> reg = service.registerNotificationListener( listener );
- * </pre>
+ * }
* The <code>onStart</code> method will be invoked when someone publishes a <code>Start</code> notification and
* the <code>onStop</code> method will be invoked when someone publishes a <code>Stop</code> notification.
*/
/**
* Called when this bundle is started (before
- * {@link #onSessionInitiated(ProviderContext)} so the Framework can perform
+ * {@link BindingAwareProvider#onSessionInitiated(ProviderContext)} so the Framework can perform
* the bundle-specific activities necessary to start this bundle. This
* method can be used to register services or to allocate any resources that
* this bundle needs.
*
* @param context
* The execution context of the bundle being started.
- * @throws Exception
+ * @throws RuntimeException
* If this method throws an exception, this bundle is marked as
* stopped and the Framework will remove this bundle's
* listeners, unregister all services registered by this bundle,
* This method must complete and return to its caller in a timely manner.
*
* @param context The execution context of the bundle being stopped.
- * @throws Exception If this method throws an exception, the bundle is still
+ * @throws RuntimeException If this method throws an exception, the bundle is still
* marked as stopped, and the Framework will remove the bundle's
* listeners, unregister all services registered by the bundle, and
* release all services used by the bundle.
* Binding-aware core of the SAL layer responsible for wiring the SAL consumers.
*
* The responsibility of the broker is to maintain registration of SAL
- * functionality {@link Consumer}s and {@link Provider}s, store provider and
+ * functionality Consumers and Providers, store provider and
* consumer specific context and functionality registration via
* {@link ConsumerContext} and provide access to infrastructure services, which
* removes direct dependencies between providers and consumers.
* The consumer is required to use returned session for all communication
* with broker or one of the broker services. The session is announced to
* the consumer by invoking
- * {@link Consumer#onSessionInitiated(ConsumerContext)}.
+ * {@link BindingAwareConsumer#onSessionInitialized(ConsumerContext)}.
*
- * @param cons
+ * @param consumer
* Consumer to be registered.
* @return a session specific to consumer registration
* @throws IllegalArgumentException
* <p>
* During the registration, the broker obtains the initial functionality
* from consumer, using the
- * {@link BindingAwareProvider#getImplementations()}, and register that
+ * BindingAwareProvider#getImplementations(), and register that
* functionality into system and concrete infrastructure services.
*
* <p>
* {@link BindingAwareProvider#onSessionInitiated(ProviderContext)}.
*
*
- * @param prov
+ * @param provider
* Provider to be registered.
* @return a session unique to the provider registration.
* @throws IllegalArgumentException
* The session serves to store SAL context (e.g. registration of
* functionality) for the consumer and provides access to the SAL
* infrastructure services and other functionality provided by
- * {@link Provider}s.
+ * {@link BindingAwareProvider}s.
*/
interface ConsumerContext extends RpcConsumerRegistry {
* Register particular instance identifier to be processed by this
* RpcService
*
- * Deprecated in favor of {@link RoutedRegistration#registerPath(Object, Object)}.
+ * Deprecated in favor of RoutedRegistration#registerPath(Object, Object).
*
* @param context
* @param instance
* Unregister particular instance identifier to be processed by this
* RpcService
*
- * Deprecated in favor of {@link RoutedRegistration#unregisterPath(Object, Object)}.
+ * Deprecated in favor of RoutedRegistration#unregisterPath(Class, InstanceIdentifier).
*
* @param context
* @param instance
* DataBroker databroker = session.getSALService(BindingDataBroker.class);
* }
* }
-* @see org.opendaylight.controller.md.sal.common.api.data.BindingDataBroker
-* for more info on using the DataBroker.
-*
*/
public interface BindingAwareConsumer {
*
* To get a NotificationService:
*
- * {code
+ * {@code
* public void onSessionInitiated(ProviderContext session) {
* NotificationProviderService notificationService = session.getSALService(NotificationProviderService.class);
* }
+ * }
* For more information on sending notifications via the NotificationProviderService
* @see org.opendaylight.controller.sal.binding.api.NotificationProviderService
*
* To register an RPC implementation:
*
- * {code
+ * {@code
* public void onSessionInitiated(ProviderContext session) {
* RpcRegistration<MyService> registration = session.addRpcImplementation(MyService.class, myImplementationInstance);
* }
+ * }
*
* <p>
- *
* Where MyService.class is a Service interface generated from a yang model with RPCs modeled in it and myImplementationInstance
* is an instance of a class that implements MyService.
*
* To register a Routed RPC Implementation:
- * {code
+ * {@code
* public void onSessionInitiated(ProviderContext session) {
* RoutedRpcRegistration<SalFlowService> flowRegistration = session.addRoutedRpcImplementation(SalFlowService.class, salFlowServiceImplementationInstance);
flowRegistration.registerPath(NodeContext.class, nodeInstanceId);
* of a class that implements SalFlowService.
* <p>
* The line:
- * {code
+ * {@code
* flowRegistration.registerPath(NodeContext.class, nodeInstanceId);
* }
* Is indicating that the RPC implementation is registered to handle RPC invocations that have their NodeContext pointing to the node with instance id nodeInstanceId.
*
* To get a DataBroker to allow access to the data tree:
*
- * {code
+ * {@code
* public void onSessionInitiated(final ProviderContext session) {
* DataBroker databroker = session.getSALService(BindingDataBroker.class);
* }
* }
- * @see org.opendaylight.controller.md.sal.common.api.data.BindingDataBroker
- * for more info on using the DataBroker.
- *
*/
public interface BindingAwareProvider {
* <li>Dispatch listener - listener, which implements <code>{ModelName}Listener</code> interface,
* which has dispatch methods for each defined notification. Methods are invoked based on notification type (class).
* </li>
+ * </ul>
*
* <h3>Generic Listener</h3>
* <p>
* are registered using {@link #registerNotificationListener(org.opendaylight.yangtools.yang.binding.NotificationListener)}
* method.
*
- * <h5>Dispatch Listener Example</h5>
+ * <h4>Dispatch Listener Example</h4>
* <p>
* Lets assume we have following YANG model:
*
- * <pre>
+ * {@code
* module example {
* ...
*
* ...
* }
* }
- * </pre>
+ * }
*
* The generated interface will be:
- * <pre>
+ * {@code
* public interface ExampleListener extends NotificationListener {
* void onStart(Start notification);
* void onStop(Stop notification);
* }
- * </pre>
+ * }
* The following defines an implementation of the generated interface:
- * <pre>
+ * {@code
* public class MyExampleListener implements ExampleListener {
* public void onStart(Start notification) {
* // do something
* // do something
* }
* }
- * </pre>
+ * }
* The implementation is registered as follows:
- * <pre>
+ * {@code
* MyExampleListener listener = new MyExampleListener();
* ListenerRegistration<NotificationListener> reg = service.registerNotificationListener( listener );
- * </pre>
+ * }
* The <code>onStart</code> method will be invoked when someone publishes a <code>Start</code> notification and
* the <code>onStop</code> method will be invoked when someone publishes a <code>Stop</code> notification.
*
* to listen for Rpc Result. This will asynchronously listen for future result in executor and
* will not block current thread.
*
- * <pre>
+ * {@code
* final Future<RpcResult<SomeRpcOutput>> future = someRpcService.someRpc( ... );
* Futures.addCallback(JdkFutureAdapters.listenInThreadPool(future), new FutureCallback<RpcResult<SomeRpcOutput>>() {
*
* // RPC failed
* }
* );
- * </pre>
+ * }
+ * }
+ *
* @param serviceInterface the interface of the RPC Service. Typically this is an interface generated
* from a YANG model.
* @return the proxy for the requested RPC service. This method never returns null.
*
* <h3>Routed RPC example</h3>
* <p>
- * <h5>1. Defining a Context Type</h5>
+ * <h4>1. Defining a Context Type</h4>
* <p>
* The following snippet declares a simple YANG <code>identity</code> named <code>example-context</code>:
*
- * <pre>
+ * {@code
* module example {
* ...
* identity example-context {
* }
* ...
* }
- * </pre>
+ * }
* <p>
* We then use the declared identity to define a context type by using it in combination
* with the <code>context-instance</code> YANG extension. We'll associate the context type
* The following YANG snippet imports the <code>yang-ext</code> module and defines the list
* element named <code>item</code> inside a container named <code>foo</code>:
*
- * <pre>
+ * {@code
* module foo {
* ...
* import yang-ext {prefix ext;}
* }
* ...
* }
- * </pre>
+ * }
* <p>
* The statement <code>ext:context-instance "example-context";</code> inside the list element
* declares that any instance identifier referencing <code>item</code> in the data
* @param serviceInterface the YANG-generated interface of the RPC Service for which to register.
* @param implementation the implementation instance to register.
* @return a RoutedRpcRegistration instance which can be used to register paths for the RPC
- * implementation via invoking {@link RoutedRpcRegistration#registerPath(....).
+ * implementation via invoking RoutedRpcRegistration#registerPath(Class, InstanceIdentifer).
* {@link RoutedRpcRegistration#close()} should be called to unregister the implementation
* and all previously registered paths when no longer needed.
*
*
* @return new blank data modification transaction.
* @deprecated Replaced by more specific transaction types. Please use
- * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadOnlyTransaction(),
- * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadWriteTransaction()
+ * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadOnlyTransaction()},
+ * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadWriteTransaction()}
* or
- * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newWriteOnlyTransaction().
+ * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newWriteOnlyTransaction()}.
*/
@Deprecated
DataModificationTransaction beginTransaction();
import org.opendaylight.yangtools.yang.common.RpcResult;
/**
- *
- *
* @deprecated Replaced by more specific transaction types. Please use
- * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadOnlyTransaction(),
- * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadWriteTransaction()
+ * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadOnlyTransaction()},
+ * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadWriteTransaction()}
* or
- * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newWriteOnlyTransaction().
- *
- *
+ * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newWriteOnlyTransaction()}.
*/
@Deprecated
public interface DataModificationTransaction extends
* Initiates a two-phase commit of candidate data.
*
* <p>
- * The {@link Consumer} could initiate a commit of candidate data
+ * The Consumer could initiate a commit of candidate data
*
* <p>
* The successful commit changes the state of the system and may affect
*
* <p>
* The effects of successful commit of data are described in the
- * specifications and YANG models describing the {@link Provider} components
- * of controller. It is assumed that {@link Consumer} has an understanding
+ * specifications and YANG models describing the Provider components
+ * of controller. It is assumed that the Consumer has an understanding
* of this changes.
*
*
- * @see org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler for further information how two-phase commit is
- * processed.
- * @param store
- * Identifier of the store, where commit should occur.
* @return Result of the commit, containing success information or list of
* encountered errors, if commit was not successful.
*/
* To get instance of synchronized wrapper use {@link #from(DataModificationTransaction)}
*
* @deprecated Replaced by more specific transaction types. Please use
- * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadOnlyTransaction(),
- * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadWriteTransaction()
+ * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadOnlyTransaction()},
+ * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newReadWriteTransaction()}
* or
- * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newWriteOnlyTransaction().
+ * {@link org.opendaylight.controller.md.sal.binding.api.DataBroker#newWriteOnlyTransaction()}.
*
*/
@Deprecated
* expected to arrive in a given time interval does not arrive. It attempts to keep track of all the messages that
* received between the arrival of two instances of the same message and the amount of time it took to process each
* of those messages.
- * <br/>
+ * <br>
* Usage of the API is as follows,
* <pre>
*
/**
* Represents behaviour that can be exhibited by actors of type {@link akka.actor.UntypedActor}
- * <p/>
+ *
+ * <p>
* This behaviour meters actor's default behaviour. It captures 2 metrics:
* <ul>
* <li>message processing rate of actor's receive block</li>
/**
* Uses 2 timers to measure message processing rate. One for overall message processing rate and
* another to measure rate by message type. The timers are re-used if they were previously created.
- * <p/>
+ *
+ * <p>
* {@link com.codahale.metrics.MetricRegistry} maintains a reservoir for different timers where
* collected timings are kept. It exposes various metrics for each timer based on collected
* data. Eg: count of messages, 99, 95, 50... percentiles, max, mean etc.
- * <p/>
+ *
+ * <p>
* These metrics are exposed as JMX bean.
*
* @see <a href="http://dropwizard.github.io/metrics/manual/core/#timers">
/**
* Represents a unified view of configuration.
- * <p/>
+ *
+ * <p>
* It merges configuration from:
* <ul>
* <li>Config subsystem</li>
/**
* The RoleChangeNotifier is responsible for receiving Raft role and leader state change messages and notifying
* the listeners (within the same node), which are registered with it.
- * <p/>
+ *
+ * <p>
* The RoleChangeNotifier is instantiated by the Shard and injected into the RaftActor.
*/
public class RoleChangeNotifier extends AbstractUntypedActor implements AutoCloseable {
/**
* An instance of a Payload class is meant to be used as the Payload for
* AppendEntries.
- * <p/>
+ *
+ * <p>
* When an actor which is derived from RaftActor attempts to persistData it
* must pass an instance of the Payload class. Similarly when state needs to
* be applied to the derived RaftActor it will be passed an instance of the
* Maintains metrics registry that is provided to reporters.
* At the moment only one reporter exists {@code JmxReporter}.
* More reporters can be added.
- * <p/>
+ *
+ * <p>
* The consumers of this class will only be interested in {@code MetricsRegistry}
* where metrics for that consumer gets stored.
*/
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
- * <p></p>
* A clustered Entity is something which is shared by multiple applications across a cluster. An Entity has a type
* and an identifier.
- * </p>
+ *
* <p>
* The type describes the type of the Entity where examples of a type maybe "openflow" or "netconf"
* etc. An Entity type could be tied to how exactly an application shares and "owns" an entity. For example we may want
* first served basis. On the other hand for netconf entity types we may want applications to gain ownership based on
* a load balancing approach. While this mechanism of assigning a ownership acquisition strategy is not finalized the
* intention is that the entity type will play a role in determining the strategy and thus should be put in place.
- * </p>
+ *
* <p>
* The identifier is a YangInstanceIdentifier. The reason for the choice of YangInstanceIdentifier is because it
* can easily be used to represent a data node. For example an inventory node represents a shared entity and it is best
* referenced by the YangInstanceIdentifier if the inventory node is stored in the data store.
- * </p>
+ *
+ * <p>
* Note that an entity identifier must conform to a valid yang schema. If there is no existing yang schema to
* represent an entity, the general-entity yang model can be used.
- * <p>
- * </p>
*/
public final class Entity implements Serializable {
private static final long serialVersionUID = 1L;
* </li>
* </ul>
* </li>
+ * </ul>
* @param request
* Commit Request submitted by client, which contains
* information about modifications and read-only view as
* </pre>
*
*
- * @see http://www.idevelopment.info/data/LDAP/LDAP_Resources/
- * SEARCH_Setting_the_SCOPE_Parameter.shtml
+ * @see <a href="http://www.idevelopment.info/data/LDAP/LDAP_Resources/SEARCH_Setting_the_SCOPE_Parameter.shtml">LDAP</a>
*/
enum DataChangeScope {
*
* <p>
* <b>Note</b>: This method may be invoked from a shared thread pool.
+ * <ul>
* <li>Implementations <b>SHOULD NOT</b> perform CPU-intensive operations on the calling thread.
* <li>Implementations <b>MUST NOT block the calling thread</b> - to do so could lead to deadlock
+ * </ul>
* scenarios.
*
*<br>
* tree
* @param <D>
* Type of data (payload), which represents data payload
- *
- * @see org.opendaylight.controller.md.sal.binding.api.ReadTransaction
- * @see org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction
*/
public interface AsyncReadTransaction<P extends Path<P>, D> extends AsyncTransaction<P, D> {
* <p>
* This call logically seals the transaction, which prevents the client from
* further changing data tree using this transaction. Any subsequent calls to
- * {@link #put(LogicalDatastoreType, Path, Object)},
- * {@link #merge(LogicalDatastoreType, Path, Object)} or
* {@link #delete(LogicalDatastoreType, Path)} will fail with
* {@link IllegalStateException}.
*
* The effects of a successful commit of data depends on data change listeners
* ({@link AsyncDataChangeListener}) and commit participants
* ({@link AsyncConfigurationCommitHandler}) that are registered with the data broker.
- * <p>
+ *
* <h3>Example usage:</h3>
* <pre>
* private void doWrite( final int tries ) {
* WriteTransaction writeTx = dataBroker.newWriteOnlyTransaction();
*
* MyDataObject data = ...;
- * InstanceIdentifier<MyDataObject> path = ...;
+ * InstanceIdentifier<MyDataObject> path = ...;
* writeTx.put( LogicalDatastoreType.OPERATIONAL, path, data );
*
- * Futures.addCallback( writeTx.submit(), new FutureCallback<Void>() {
+ * Futures.addCallback( writeTx.submit(), new FutureCallback<Void>() {
* public void onSuccess( Void result ) {
* // succeeded
* }
*
* public void onFailure( Throwable t ) {
* if( t instanceof OptimisticLockFailedException ) {
- * if( ( tries - 1 ) > 0 ) {
+ * if( ( tries - 1 ) < 0 ) {
* // do retry
* doWrite( tries - 1 );
* } else {
* which are based on same initial state, Tx 1 completes successfully
* before Tx 2 is submitted.
*
- * <table>
+ * <table summary="">
* <tr><th>Initial state</th><th>Tx 1</th><th>Tx 2</th><th>Result</th></tr>
* <tr><td>Empty</td><td>put(A,1)</td><td>put(A,2)</td><td>Tx 2 will fail, state is A=1</td></tr>
* <tr><td>Empty</td><td>put(A,1)</td><td>merge(A,2)</td><td>A=2</td></tr>
* which are based on same initial state, Tx 1 completes successfully
* before Tx 2 is submitted.
*
- * <table>
+ * <table summary="">
* <tr><th>Initial state</th><th>Tx 1</th><th>Tx 2</th><th>Result</th></tr>
*
* <tr><td>Empty</td><td>put(TOP,[])</td><td>put(TOP,[])</td><td>Tx 2 will fail, state is TOP=[]</td></tr>
* controller. It is assumed that Consumer has an understanding of this
* changes.
*
- *
- * @see DataCommitHandler for further information how two-phase commit is
- * processed.
- * @param store
- * Identifier of the store, where commit should occur.
* @return Result of the Commit, containing success information or list of
* encountered errors, if commit was not successful. The Future
* blocks until {@link TransactionStatus#COMMITED} or
* t1.submit();
*
* AsyncReadTransaction t2 = broker.newReadOnlyTransaction();
- * Optional<?> maybeData = t2.read(id).get();
+ * Optional<?> maybeData = t2.read(id).get();
*
* it may happen, that it sees maybeData.isPresent() == false, simply because
* t1 has not completed the processes of being applied and t2 is actually
import org.opendaylight.yangtools.util.concurrent.ListenerNotificationQueueStats;
/**
- * MXBean interface for {@link QueuedNotificationManager} statistic metrics.
+ * MXBean interface for {@link org.opendaylight.yangtools.util.concurrent.QueuedNotificationManager} statistic metrics.
*
* @author Thomas Pantelis
*/
/**
* Actor for a DataChangeListener.
*
- * @Deprecated Replaced by {@link DataTreeChangeListener}
+ * @deprecated Replaced by {@link DataTreeChangeListener}
*/
@Deprecated
public class DataChangeListener extends AbstractUntypedActor {
/**
* A Shard represents a portion of the logical data tree.
- * <p/>
+ *
+ * <p>
* Our Shard uses InMemoryDataTree as it's internal representation and delegates all requests it
*/
public class Shard extends RaftActor {
* Internal shard state, similar to a DOMStore, but optimized for use in the actor system,
* e.g. it does not expose public interfaces and assumes it is only ever called from a
* single thread.
- * <p/>
+ *
+ * <p>
* This class is not part of the API contract and is subject to change at any time.
*/
@NotThreadSafe
* Invoked by {@link TransactionContextWrapper} when it has finished handing
* off operations to this context. From this point on, the context is responsible
* for throttling operations.
- * <p/>
+ *
+ * <p>
* Implementations can rely on the wrapper calling this operation in a synchronized
* block, so they do not need to ensure visibility of this state transition themselves.
*/
/**
* A {@link Mapper} extracting the {@link ActorSelection} pointing to the actor which
* is backing a particular transaction.
- * <p/>
+ *
+ * <p>
* This class is not for general consumption. It is public only to support the pre-lithium compatibility
* package.
* TODO: once we remove compatibility, make this class package-private and final.
/**
* A message about a DataTree having been changed. The message is not
* serializable on purpose. For delegating the change across cluster nodes,
- * this needs to be intercepted by a local agent and forwarded as
- * a {@link DataTreeDelta}.
+ * this needs to be intercepted by a local agent and forwarded as reconstructed
+ * candidate.
*/
public final class DataTreeChanged {
private final Collection<DataTreeCandidate> changes;
/**
* FindLocalShard is a message that should be sent to the
- * {@link org.opendaylight.controller.cluster.datastore.shardmanager.ShardManager} when we need to find a reference
+ * org.opendaylight.controller.cluster.datastore.shardmanager.ShardManager when we need to find a reference
* to a LocalShard.
*/
public class FindLocalShard {
private final String shardName;
private final boolean waitUntilInitialized;
- public FindLocalShard(String shardName, boolean waitUntilInitialized) {
+ public FindLocalShard(final String shardName, final boolean waitUntilInitialized) {
this.shardName = shardName;
this.waitUntilInitialized = waitUntilInitialized;
}
/**
* LocalShardFound is a message that is sent by the
- * {@link org.opendaylight.controller.cluster.datastore.shardmanager.ShardManager}
+ * org.opendaylight.controller.cluster.datastore.shardmanager.ShardManager
* when it finds a shard with the specified name in it's local shard registry.
*/
public class LocalShardFound {
private final ActorRef path;
- public LocalShardFound(ActorRef path) {
+ public LocalShardFound(final ActorRef path) {
this.path = path;
}
/**
* LocalShardNotFound is a message that is sent by the
- * {@link org.opendaylight.controller.cluster.datastore.shardmanager.ShardManager}
+ * org.opendaylight.controller.cluster.datastore.shardmanager.ShardManager
* when it cannot locate a shard in it's local registry with the shardName specified.
*/
public class LocalShardNotFound {
*
* @param shardName the name of the shard that could not be found
*/
- public LocalShardNotFound(String shardName) {
+ public LocalShardNotFound(final String shardName) {
this.shardName = shardName;
}
/**
* Represents a modification to the data store.
+ *
* <p>
* Simple modifications can be of type,
+ * <ul>
* <li> {@link org.opendaylight.controller.cluster.datastore.modification.WriteModification}
* <li> {@link org.opendaylight.controller.cluster.datastore.modification.MergeModification}
* <li> {@link org.opendaylight.controller.cluster.datastore.modification.DeleteModification}
- * </p>
+ * </ul>
*
* <p>
* Modifications can in turn be lumped into a single
* {@link org.opendaylight.controller.cluster.datastore.modification.CompositeModification}
* which can then be applied to a write transaction.
- * </p>
*/
public interface Modification extends Externalizable {
/**
* Enumeration of all ABI versions supported by this implementation of persistence. An ABI version has to be bumped
* whenever:
- * - a new event is defined
- * - serialization format is changed
- * <p/>
+ * <ul>
+ * <li>a new event is defined</li>
+ * <li>serialization format is changed</li>
+ * </ul>
+ *
+ * <p>
* This version effectively defines the protocol version between actors participating on a particular shard. A shard
* participant instance should oppose RAFT candidates which produce persistence of an unsupported version. If a follower
* encounters an unsupported version it must not become fully-operational, as it does not have an accurate view
* an interface because we want to make sure all subclasses implement the externalizable proxy pattern, for which
* we need to force {@link #writeReplace()} to be abstract. We do that by making it final and exposing a protected
* {@link #externalizableProxy()} method.
- * <p/>
+ *
+ * <p>
* All concrete subclasses of this class should be final so as to form a distinct set of possible metadata. Since
* metadata is serialized along with {@link MetadataShardDataTreeSnapshot}, this set is part of the serialization format
* guarded by {@link PayloadVersion}.
- * <p/>
+ *
+ * <p>
* If a new metadata type is introduced or a type is removed, {@link PayloadVersion} needs to be bumped to ensure
* compatibility.
*
public interface ShardStrategy {
/**
* Find the name of the shard in which the data pointed to by the specified path belongs in.
- * <p/>
+ *
+ * <p>
* Should return the name of the default shard DefaultShardStrategy.DEFAULT_SHARD
* if no matching shard was found
*
* a connection to external subtree source is broken. The listener will not receive any other
* callbacks, but its registration still needs to be closed to prevent resource leak.
*
- * @param cause Collection of failure causes, may not be null or empty.
+ * @param causes Collection of failure causes, may not be null or empty.
*/
void onDataTreeFailed(@Nonnull Collection<DOMDataTreeListeningException> causes);
}
* previously allocated must have been either submitted or cancelled by the
* time this method is invoked.
*
- * @param barrier Indicates whether this transaction should be a barrier. A barrier
+ * @param isolated Indicates whether this transaction should be a barrier. A barrier
* transaction is processed separately from any preceding transactions.
* Non-barrier transactions may be merged and processed in a batch,
* such that any observers see the modifications contained in them as
* if the modifications were made in a single transaction.
* @return A new {@link DOMDataWriteTransaction}
- * @throws {@link IllegalStateException} if a previous transaction was not closed.
- * @throws {@link IllegalThreadStateException} if the calling thread context does not
+ * @throws IllegalStateException if a previous transaction was not closed.
+ * @throws IllegalThreadStateException if the calling thread context does not
* match the lifecycle rules enforced by the producer state (e.g. bound or unbound).
* This exception is thrown on a best effort basis and programs should not rely
* on it for correct operation.
* Once this method returns successfully, this (parent) producer loses the ability to
* access the specified paths until the resulting (child) producer is shut down.
*
- * @throws {@link IllegalStateException} if there is an open transaction
- * @throws {@link IllegalArgumentException} if subtrees contains a subtree which is not
+ * @throws IllegalStateException if there is an open transaction
+ * @throws IllegalArgumentException if subtrees contains a subtree which is not
* accessible by this producer
- * @throws {@link IllegalThreadStateException} if the calling thread context does not
+ * @throws IllegalThreadStateException if the calling thread context does not
* match the lifecycle rules enforced by the producer state (e.g. bound or unbound).
* This exception is thrown on a best effort basis and programs should not rely
* on it for correct operation.
*
* @param subtrees The collection of subtrees the resulting producer should have access to.
* @return A {@link DOMDataTreeProducer} instance.
- * @throws {@link IllegalArgumentException} if subtrees is empty.
+ * @throws IllegalArgumentException if subtrees is empty.
*/
@Nonnull DOMDataTreeProducer createProducer(@Nonnull Collection<DOMDataTreeIdentifier> subtrees);
}
* feedback loop
*/
@Nonnull <T extends DOMDataTreeListener> ListenerRegistration<T> registerListener(@Nonnull T listener,
- @Nonnull Collection<DOMDataTreeIdentifier> subtrees, boolean allowRxMerges, @Nonnull Collection<DOMDataTreeProducer> producers);
+ @Nonnull Collection<DOMDataTreeIdentifier> subtrees, boolean allowRxMerges, @Nonnull Collection<DOMDataTreeProducer> producers) throws DOMDataTreeLoopException;
}
*/
public interface DOMDataWriteTransaction extends AsyncWriteTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
+ @Override
+ void delete(LogicalDatastoreType store, YangInstanceIdentifier path);
+
/**
* Stores a piece of data at the specified path. This acts as an add / replace
* operation, which is to say that whole subtree will be replaced by the specified data.
* Aside for marking these, they also provide runtime query to detect whether
* a particular trait is in fact available.
*
- * <T> Base {@link DOMService}
- * <E> Extension type
+ * @param <T> Base {@link DOMService}
+ * @param <E> Extension type
*/
@Beta
public interface DOMExtensibleService<T extends DOMExtensibleService<T, E>, E extends DOMServiceExtension<T, E>> extends DOMService {
* Abstract subclasses can refine the return type as returning a promise of a
* more specific type, e.g.:
*
+ * {@code
* public interface DeliveryStatus { int getListenerCount(); }
* ListenableFuture<? extends DeliveryStatus> putNotification(DOMNotification notification);
+ * }
*
* Once the Future succeeds, the resulting object can be queried for traits using
* instanceof, e.g:
*
+ * {@code
* // Can block when (for example) the implemention's ThreadPool queue is full
* Object o = service.putNotification(notif).get();
* if (o instanceof DeliveryStatus) {
* @param notification Notification to be published.
* @return A listenable future which will report completion when the service
* has finished propagating the notification to its immediate registrants,
- * or {@value #REJECTED} if resource constraints prevent
+ * or {@link #REJECTED} if resource constraints prevent
* the implementation from accepting the notification for delivery.
* @throws NullPointerException if notification is null.
*/
* @param unit a TimeUnit determining how to interpret the timeout parameter
* @return A listenable future which will report completion when the service
* has finished propagating the notification to its immediate registrants,
- * or {@value #REJECTED} if resource constraints prevent
+ * or {@link #REJECTED} if resource constraints prevent
* the implementation from accepting the notification for delivery.
* @throws InterruptedException if interrupted while waiting
* @throws NullPointerException if notification or unit is null.
* <p>
* This exception indicates that given notification can not be processed by corresponding mechanism.
* More info can be provided in message.
- * <p/>
+ *
* <p>
* Expected use: {@link DOMNotificationPublishService}
- * </p>
*/
public class DOMNotificationRejectedException extends Exception {
private static final long serialVersionUID = 1L;
* @param listener Notification instance to register
* @param types Notification types which should be delivered to the listener. Duplicate
* entries are processed only once, null entries are ignored.
- * @return Registration handle. Invoking {@link DOMNotificationListenerRegistration#close()}
+ * @return Registration handle. Invoking {@link ListenerRegistration#close()}
* will stop the delivery of notifications to the listener
* @throws IllegalArgumentException if types is empty or contains an invalid element, such as
* null or a SchemaPath which does not represent a valid {@link DOMNotification} type.
* @param listener Notification instance to register
* @param types Notification types which should be delivered to the listener. Duplicate
* entries are processed only once, null entries are ignored.
- * @return Registration handle. Invoking {@link DOMNotificationListenerRegistration#close()}
+ * @return Registration handle. Invoking {@link ListenerRegistration#close()}
* will stop the delivery of notifications to the listener
* @throws IllegalArgumentException if types is empty or contains an invalid element, such as
* null or a SchemaPath which does not represent a valid {@link DOMNotification} type.
* to prevent this scenario from occurring.
*
* @param listener {@link DOMRpcAvailabilityListener} instance to register
- * @return A {@link DOMRpcAvailabilityListenerRegistration} representing this registration. Performing
- * a {@link DOMRpcAvailabilityListenerRegistration#close()} will cancel it. Returned object
+ * @return A {@link ListenerRegistration} representing this registration. Performing
+ * a {@link ListenerRegistration#close()} will cancel it. Returned object
* is guaranteed to be non-null.
*/
@Nonnull <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(@Nonnull T listener);
* @deprecated - no longer used or needed
* *
* Suggested implementation until removed:
- * @code {
+ * {@code
* public Collection<ConsumerFunctionality> getConsumerFunctionality() {
* return Collections.emptySet();
* }
* @deprecated - No longer used or needed
*
* Suggested implementation until removed:
- * @code {
+ * {@code
* public Collection<ProviderFunctionality> getProviderFunctionality() {
* return Collections.emptySet();
* }
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
*
* Subtransaction for reading is selected by supplied
* {@link LogicalDatastoreType} as parameter for
- * {@link DOMDataReadOnlyTransaction#read(LogicalDatastoreType,org.opendaylight.yangtools.yang.data.api.InstanceIdentifier)}
+ * {@link DOMDataReadOnlyTransaction#read(LogicalDatastoreType,org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)}
* .
*
* Id of returned transaction is retrieved via
* <p>
* Implementation of composite Write-only transaction is following:
*
- * <ul>
- * <li>
- * {@link DOMDataWriteTransaction#put(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
+ * <ul><li>
+ * {@link DOMDataWriteTransaction#put(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
* - backing subtransaction is selected by {@link LogicalDatastoreType},
- * {@link DOMStoreWriteTransaction#write(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
+ * {@link DOMStoreWriteTransaction#write(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
* is invoked on selected subtransaction.
- * <li>
- * {@link DOMDataWriteTransaction#merge(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
+ * </li><li>
+ * {@link DOMDataWriteTransaction#merge(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
* - backing subtransaction is selected by {@link LogicalDatastoreType},
- * {@link DOMStoreWriteTransaction#merge(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
+ * {@link DOMStoreWriteTransaction#merge(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
* is invoked on selected subtransaction.
- * <li>
- * {@link DOMDataWriteTransaction#delete(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier)
+ * </li><li>
+ * {@link DOMDataWriteTransaction#delete(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)}
* - backing subtransaction is selected by {@link LogicalDatastoreType},
- * {@link DOMStoreWriteTransaction#delete(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier)} is invoked on
+ * {@link DOMStoreWriteTransaction#delete(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)} is invoked on
* selected subtransaction.
- * <li> {@link DOMDataWriteTransaction#commit()} - results in invoking
+ * </li><li> {@link DOMDataWriteTransaction#commit()} - results in invoking
* {@link DOMStoreWriteTransaction#ready()}, gathering all resulting cohorts
* and then invoking finalized implementation callback
- * {@link #submit(DOMDataWriteTransaction, Iterable)} with transaction which
+ * {@link #submit(DOMDataWriteTransaction, Collection)} with transaction which
* was commited and gathered results.
+ * </li>
* </ul>
*
* Id of returned transaction is generated via
*
* <ul>
* <li>
- * {@link DOMDataWriteTransaction#read(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier)}
+ * {@link DOMDataReadTransaction#read(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)}
* - backing subtransaction is selected by {@link LogicalDatastoreType},
- * {@link DOMStoreWriteTransaction#read(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier)} is invoked on
+ * {@link DOMStoreReadTransaction#read(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)} is invoked on
* selected subtransaction.
* <li>
- * {@link DOMDataWriteTransaction#put(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
+ * {@link DOMDataWriteTransaction#put(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
* - backing subtransaction is selected by {@link LogicalDatastoreType},
- * {@link DOMStoreWriteTransaction#write(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
+ * {@link DOMStoreWriteTransaction#write(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
* is invoked on selected subtransaction.
* <li>
- * {@link DOMDataWriteTransaction#merge(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
+ * {@link DOMDataWriteTransaction#merge(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
* - backing subtransaction is selected by {@link LogicalDatastoreType},
- * {@link DOMStoreWriteTransaction#merge(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
+ * {@link DOMStoreWriteTransaction#merge(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode)}
* is invoked on selected subtransaction.
* <li>
- * {@link DOMDataWriteTransaction#delete(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier)
+ * {@link DOMDataWriteTransaction#delete(LogicalDatastoreType, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)}
* - backing subtransaction is selected by {@link LogicalDatastoreType},
- * {@link DOMStoreWriteTransaction#delete(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier)} is invoked on
+ * {@link DOMStoreWriteTransaction#delete(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier)} is invoked on
* selected subtransaction.
* <li> {@link DOMDataWriteTransaction#commit()} - results in invoking
* {@link DOMStoreWriteTransaction#ready()}, gathering all resulting cohorts
* and then invoking finalized implementation callback
- * {@link #submit(DOMDataWriteTransaction, Iterable)} with transaction which
- * was commited and gathered results.
+ * {@link #submit(DOMDataWriteTransaction, Collection)} with transaction which
+ * was committed and gathered results.
* <li>
* </ul>
*
*
* It can optionally capture the context where it was allocated.
*
- * <T> identifier type
+ * @param <T> identifier type
*/
@Beta
public abstract class AbstractDOMStoreTransaction<T> implements DOMStoreTransaction {
* Interface implemented by the {@link DOMStore} and exposed for each {@link DOMStoreWriteTransaction}
* upon its transition to Ready state. The frontend (DOMStore user) uses this interface to drive the
* commit procedure across potentially multiple DOMStores using the Three-Phase-Commit (3PC) Protocol,
- * as described in {@link https://en.wikipedia.org/wiki/Three-phase_commit}.
+ * as described in <a href="https://en.wikipedia.org/wiki/Three-phase_commit">Three-Phase-Commit Protocol</a>.
*/
public interface DOMStoreThreePhaseCommitCohort {
* true if transaction is approved by data store.
* <li>false if the transaction is not approved by data store and
* should be aborted.
+ * </ul>
*/
ListenableFuture<Boolean> canCommit();
* specified path.
*
* If you need add or merge of current object with specified use
- * {@link #merge(org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType, org.opendaylight.yangtools.concepts.Path, Object)}
+ * {@link #merge(YangInstanceIdentifier, NormalizedNode)}.
*
*
* @param path
* operation, which is to say that whole subtree will be replaced by
* specified path.
*
- * If you need add or merge of current object with specified use
- * {@link #merge(org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType, org.opendaylight.yangtools.concepts.Path, Object)}
- *
- *
* @param path
* @param data
* Data object to be written
* Implementation of read-only transaction backed by {@link DataTreeSnapshot}
* which delegates most of its calls to similar methods provided by underlying snapshot.
*
- * <T> identifier type
+ * @param <T> identifier type
*/
@Beta
public final class SnapshotBackedReadTransaction<T> extends AbstractDOMStoreTransaction<T> implements DOMStoreReadTransaction {
}
/**
- * Prototype implementation of
- * {@link #ready(org.opendaylight.controller.sal.core.spi.data.SnapshotBackedWriteTransaction)}
- *
* This class is intended to be implemented by Transaction factories
* responsible for allocation of {@link org.opendaylight.controller.sal.core.spi.data.SnapshotBackedWriteTransaction} and
* providing underlying logic for applying implementation.
*/
protected abstract DOMStoreThreePhaseCommitCohort transactionReady(SnapshotBackedWriteTransaction<T> tx, DataTreeModification tree);
}
-}
\ No newline at end of file
+}
</plugins>
</build>
- <profiles>
- <!-- Turn off doclint. -->
- <profile>
- <id>jdk8</id>
- <activation>
- <jdk>[1.8,)</jdk>
- </activation>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <configuration>
- <additionalparam>-Xdoclint:none</additionalparam>
- </configuration>
- </plugin>
- </plugins>
- </build>
- </profile>
- </profiles>
-
<scm>
<connection>scm:git:http://git.opendaylight.org/gerrit/controller.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
/**
* Registry to look up cluster nodes that have registered for a given rpc.
- * <p/>
+ *
+ * <p>
* It uses {@link org.opendaylight.controller.remote.rpc.registry.gossip.BucketStore} to maintain this
* cluster wide information.
*/
/**
* Gossiper that syncs bucket store across nodes in the cluster.
- * <p/>
+ *
+ * <p>
* It keeps a local scheduler that periodically sends Gossip ticks to
* itself to send bucket store's bucket versions to a randomly selected remote
* gossiper.
- * <p/>
+ *
+ * <p>
* When bucket versions are received from a remote gossiper, it is compared
* with bucket store's bucket versions. Which ever buckets are newer
* locally, are sent to remote gossiper. If any bucket is older in bucket store,
* a gossip status is sent to remote gossiper so that it can send the newer buckets.
- * <p/>
+ *
+ * <p>
* When a bucket is received from a remote gossiper, its sent to the bucket store
* for update.
- *
*/
public class Gossiper extends AbstractUntypedActorWithMetering {
<tag>HEAD</tag>
<url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:Main</url>
</scm>
-
- <profiles>
- <!-- Turn off doclint on aggregated API javadoc build. -->
- <profile>
- <id>jdk8</id>
- <activation>
- <jdk>[1.8,)</jdk>
- </activation>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <configuration>
- <additionalparam>-Xdoclint:none</additionalparam>
- </configuration>
- </plugin>
- </plugins>
- </build>
- </profile>
- </profiles>
</project>
Code Review / controller.git / commitdiff