Class AbstractTransportMapping<A extends Address>

java.lang.Object
org.snmp4j.transport.AbstractTransportMapping<A>
All Implemented Interfaces:
Closeable, AutoCloseable, TransportMapping<A>
Direct Known Subclasses:
AbstractConnectionOrientedTransportMapping, DummyTransport, DummyTransport.DummyTransportResponder, UdpTransportMapping
public abstract class AbstractTransportMapping<A extends Address> extends Object implements TransportMapping<A>
The AbstractTransportMapping provides an abstract implementation for the message dispatcher list and the maximum inbound message size.
Version:
3.12.0
Author:
Frank Fock

  • Field Details

    • transportListener

      protected List<TransportListener> transportListener

    • transportAuditListeners

      protected transient volatile List<TransportAuditListener> transportAuditListeners

    • maxInboundMessageSize

      protected int maxInboundMessageSize

    • asyncMsgProcessingSupported

      protected boolean asyncMsgProcessingSupported

    • suspendedAddresses

      protected Set<A extends Address> suspendedAddresses

    • listenWorkerTask

      protected WorkerTask listenWorkerTask

    • transportStateListeners

      protected transient List<TransportStateListener> transportStateListeners

    • connectionTimeout

      protected long connectionTimeout

    • socketCleaner

      protected CommonTimer socketCleaner

  • Constructor Details

    • AbstractTransportMapping

      protected AbstractTransportMapping()

  • Method Details

    • getSupportedAddressClass

      public abstract Class<? extends Address> getSupportedAddressClass()
      Description copied from interface: TransportMapping
      Gets the primary Address class that is supported by this transport mapping.
      Specified by:
      getSupportedAddressClass in interface TransportMapping<A extends Address>
      Returns:
      a subclass of Address.

    • isListening

      public boolean isListening()
      Description copied from interface: TransportMapping
      Returns true if the transport mapping is listening for incoming messages. For connection oriented transport mappings this is a prerequisite to be able to send SNMP messages. For connectionless transport mappings it is a prerequisite to be able to receive responses.
      Specified by:
      isListening in interface TransportMapping<A extends Address>
      Returns:
      true if this transport mapping is listening for messages.

    • sendMessage

      public abstract void sendMessage(A address, byte[] message, TransportStateReference tmStateReference, long timeoutMillis, int maxRetries) throws IOException
      Sends a message to the supplied address using this transport. If the target address has been suspended, then instead actually sending the message on the wire, the method handleDroppedMessageToSend(Address, byte[], TransportStateReference, long, int) will be called. To stop suspending of a target address, call resumeAddress(Address) for that address.
      Specified by:
      sendMessage in interface TransportMapping<A extends Address>
      Parameters:
      address - an Address instance denoting the target address.
      message - the whole message as an array of bytes.
      tmStateReference - the (optional) transport model state reference as defined by RFC 5590 section 6.1.
      timeoutMillis - maximum number of milliseconds the connection creation might take (if connection-based).
      maxRetries - maximum retries during connection creation.
      Throws:
      IOException - if any underlying IO operation fails.

    • addTransportListener

      public void addTransportListener(TransportListener l)
      Description copied from interface: TransportMapping
      Adds a transport listener to the transport. Normally, at least one transport listener needs to be added to process incoming messages.
      Specified by:
      addTransportListener in interface TransportMapping<A extends Address>
      Parameters:
      l - a TransportListener instance.

    • removeTransportListener

      public void removeTransportListener(TransportListener l)
      Description copied from interface: TransportMapping
      Removes a transport listener. Incoming messages will no longer be propagated to the supplied TransportListener.
      Specified by:
      removeTransportListener in interface TransportMapping<A extends Address>
      Parameters:
      l - a TransportListener instance.

    • removeAllTransportListeners

      public void removeAllTransportListeners()

    • addTransportAuditListener

      public void addTransportAuditListener(TransportAuditListener l)
      Adds a TransportAuditListener that is able to control (allow/deny) and audit the communication of this transport mapping. If the same listener is already registered, it is not added again.
      Parameters:
      l - the TransportAuditListener to add.
      Since:
      3.12.0

    • removeTransportAuditListener

      public void removeTransportAuditListener(TransportAuditListener l)
      Removes a previously added TransportAuditListener.
      Parameters:
      l - the TransportAuditListener to remove.
      Since:
      3.12.0

    • removeAllTransportAuditListeners

      public void removeAllTransportAuditListeners()
      Removes all registered TransportAuditListeners.
      Since:
      3.12.0

    • isTransportAudit

      public boolean isTransportAudit()
      Checks whether at least one TransportAuditListener is registered with this transport mapping. This method can be used to quickly check whether building and firing a TransportAuditEvent is necessary at all, in order to avoid the associated overhead when no audit listener is registered.
      Returns:
      true if at least one TransportAuditListener is registered, false otherwise.
      Since:
      3.12.0

    • getAuditListenAddress

      protected A getAuditListenAddress()
      Returns the listen address of this transport mapping for use in TransportAuditEvents without propagating exceptions. Some transport mappings throw an exception from getListenAddress() when they are not listening yet; this helper returns null in that case so that audit event creation never fails.
      Returns:
      the listen address or null if it cannot be determined.
      Since:
      3.12.0

    • fireTransportAuditEvent

      protected boolean fireTransportAuditEvent(TransportAuditEvent event)
      Notifies all registered TransportAuditListeners about the supplied TransportAuditEvent. All listeners are always notified (so that they can audit the event), even if one of them denies the operation.
      Parameters:
      event - the TransportAuditEvent to fire.
      Returns:
      true if the operation described by event is permitted (i.e. no listener denied it or no listener is registered at all), false if at least one listener denied the operation. For TransportAuditEvent.TransportOperation.CLOSE events the result should be ignored by the caller.
      Since:
      3.12.0

    • fireProcessMessage

      protected void fireProcessMessage(A address, ByteBuffer buf, TransportStateReference tmStateReference)
      Processes an incoming message received from the specified address and notifies the registered transport listeners. If transport auditing is enabled, an audit event will be fired before processing the message.
      Parameters:
      address - the address of the sender from which the message is received
      buf - the ByteBuffer containing the received message
      tmStateReference - a reference to the transport state associated with this message

    • close

      public abstract void close() throws IOException
      Closes this resource and releases any associated system resources. If the resource is already closed, invoking this method has no effect.
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Specified by:
      close in interface TransportMapping<A extends Address>
      Throws:
      IOException - if an I/O error occurs while closing the resource

    • suspendAddress

      public void suspendAddress(A addressToSuspendSending)
      Suspend sending of messages to the specified address, regardless if a connection is already established or not. To be able to send messages again to the specified address using sendMessage(Address, byte[], TransportStateReference, long, int), call resumeAddress(Address).
      Parameters:
      addressToSuspendSending - an arbitrary remote address for which any messages send by sendMessage(Address, byte[], TransportStateReference, long, int) should be dropped before sending and reopening a connection to that address.
      Since:
      3.4.4

    • resumeAddress

      public boolean resumeAddress(A addressToResumeSending)
      Resume sending of messages to the specified address.
      Parameters:
      addressToResumeSending - an arbitrary remote address for which any messages send by sendMessage(Address, byte[], TransportStateReference, long, int) should be dropped before sending and reopening a connection to that address.
      Returns:
      true if the specified address was previously suspended and is now resumed to allow sending messages, false otherwise.
      Since:
      3.4.4

    • handleDroppedMessageToSend

      protected void handleDroppedMessageToSend(A address, byte[] message, TransportStateReference transportStateReference, long timeoutMillis, int maxRetries)
      Handle a message that could not be send to the specified address, because there is no server socket for receiving responses.
      Parameters:
      address - an Address instance denoting the target address.
      message - the whole message as an array of bytes.
      transportStateReference - the (optional) transport model state reference as defined by RFC 5590 section 6.1.
      timeoutMillis - maximum number of milliseconds the connection creation might take (if connection based).
      maxRetries - maximum retries during connection creation.
      Since:
      3.4.4

    • listen

      public abstract void listen() throws IOException
      Starts listening for incoming connections or events. This method is intended to be implemented by subclasses to define the specific behavior required for listening operations in various contexts (e.g., network connections, event streams).
      Specified by:
      listen in interface TransportMapping<A extends Address>
      Throws:
      IOException - if an I/O error occurs during the listening process.

    • getSocketCleaner

      public CommonTimer getSocketCleaner()
      Gets the CommonTimer that controls socket cleanup operations.
      Returns:
      a socket cleaner timer.
      Since:
      3.0

    • getMaxInboundMessageSize

      public int getMaxInboundMessageSize()
      Description copied from interface: TransportMapping
      Gets the maximum length of an incoming message that can be successfully processed by this transport mapping implementation.
      Specified by:
      getMaxInboundMessageSize in interface TransportMapping<A extends Address>
      Returns:
      an integer > 484.

    • isAsyncMsgProcessingSupported

      public boolean isAsyncMsgProcessingSupported()
      Returns true if asynchronous (multi-threaded) message processing may be implemented. The default is true.
      Returns:
      if false is returned the MessageDispatcher.processMessage(org.snmp4j.TransportMapping, org.snmp4j.smi.Address, java.nio.ByteBuffer, org.snmp4j.TransportStateReference) method must not return before the message has been entirely processed.

    • setAsyncMsgProcessingSupported

      public void setAsyncMsgProcessingSupported(boolean asyncMsgProcessingSupported)
      Specifies whether this transport mapping has to support asynchronous messages processing or not.
      Parameters:
      asyncMsgProcessingSupported - if false the MessageDispatcher.processMessage(org.snmp4j.TransportMapping, org.snmp4j.smi.Address, java.nio.ByteBuffer, org.snmp4j.TransportStateReference) method must not return before the message has been entirely processed, because the incoming message buffer is not copied before the message is being processed. If true the message buffer is copied for each call, so that the message processing can be implemented asynchronously.

    • setPriority

      public void setPriority(int newPriority)
      Changes the priority of the listen thread for this UDP transport mapping. This method has no effect, if called before listen() has been called for this transport mapping.
      Parameters:
      newPriority - the new priority.
      Since:
      3.6.0
      See Also:

    • getPriority

      public int getPriority()
      Returns the priority of the internal listen thread.
      Returns:
      a value between Thread.MIN_PRIORITY and Thread.MAX_PRIORITY.
      Since:
      3.6.0

    • setThreadName

      public void setThreadName(String name)
      Sets the name of the listen thread for this UDP transport mapping. This method has no effect, if called before listen() has been called for this transport mapping.
      Parameters:
      name - the new thread name.
      Since:
      3.6.0

    • getThreadName

      public String getThreadName()
      Returns the name of the listen thread.
      Returns:
      the thread name if in listening mode, otherwise null.
      Since:
      3.6.0

    • addTransportStateListener

      public void addTransportStateListener(TransportStateListener l)
      Add a TransportStateListener to get TransportStateEvents if the state of this transport mapping changes.
      Parameters:
      l - the listener callback interface.
      Since:
      3.7.0

    • removeTransportStateListener

      public void removeTransportStateListener(TransportStateListener l)
      Remove a TransportStateListener from this transport mapping.
      Parameters:
      l - the listener callback interface to be removed.
      Since:
      3.7.0

    • getListenAddress

      public abstract A getListenAddress()
      Description copied from interface: TransportMapping
      Returns the address that represents the actual incoming address this transport mapping uses to listen for incoming packets.
      Specified by:
      getListenAddress in interface TransportMapping<A extends Address>
      Returns:
      the address for incoming packets or null this transport mapping is not configured to listen for incoming packets.

    • fireConnectionStateChanged

      protected void fireConnectionStateChanged(TransportStateEvent change)

    • getListenWorkerTask

      public WorkerTask getListenWorkerTask()
      Gets the WorkerTask that is responsible for receiving new messages.
      Returns:
      a WorkerTask instance which is most likely a DefaultThreadFactory.WorkerThread.
      Since:
      3.7.0

    • getSuspendedAddresses

      public Set<A> getSuspendedAddresses()
      Gets an unmodifiable set of the suspended addresses of this
      Returns:
      an unmodifiable set of the suspended addresses.