Class Ctx

java.lang.Object

zmq.Ctx

public class Ctx
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	Ctx.ChannelForwardHolder	A class that holds the informations needed to forward channel in monitor sockets.
static class	Ctx.Endpoint
private static class	Ctx.PendingConnection
private static enum	Ctx.Side

Field Summary

Fields

Modifier and Type	Field	Description
private boolean	active
private boolean	blocky
private final Deque<Integer>	emptySlots
private final Map<String, Ctx.Endpoint>	endpoints
private final Lock	endpointsSync
private final Errno	errno
private Thread.UncaughtExceptionHandler	exhandler
private Thread.UncaughtExceptionHandler	exnotification
private Ctx.ChannelForwardHolder	forwardHolder
private int	ioThreadCount
private final List<IOThread>	ioThreads
private boolean	ipv6
private static AtomicInteger	maxSocketId
private int	maxSockets
private final Lock	optSync
private final MultiMap<String, Ctx.PendingConnection>	pendingConnections
private Reaper	reaper
private static final int	REAPER_TID
private final List<Selector>	selectors
private final Lock	selectorSync
private int	slotCount
private IMailbox[]	slots
private final Lock	slotSync
private final List<SocketBase>	sockets
private final AtomicBoolean	starting
(package private) static final int	TERM_TID
private boolean	terminating
private final Mailbox	termMailbox
private static final int	WAIT_FOREVER

Constructor Summary

Constructors

Constructor	Description
Ctx()

Method Summary

Modifier and Type	Method	Description
boolean	checkTag()	Deprecated. use isActive() instead
(package private) IOThread	chooseIoThread(long affinity)
private void	cleanForwarded()	Clean all empty references
boolean	closeSelector(Selector selector)
private void	connectInprocSockets(SocketBase bindSocket, Options bindOptions, Ctx.PendingConnection pendingConnection, Ctx.Side side)
(package private) void	connectPending(String addr, SocketBase bindSocket)
Selector	createSelector()
SocketBase	createSocket(int type)
private void	destroy()
(package private) void	destroySocket(SocketBase socket)
Errno	errno()
(package private) Ctx.Endpoint	findEndpoint(String addr)
(package private) int	forwardChannel(SelectableChannel channel)	Forward a channel in a monitor socket.
int	get(int option)
(package private) SelectableChannel	getForwardedChannel(Integer handle)	Retrieve a channel, using the handle returned by forwardChannel(SelectableChannel).
Thread.UncaughtExceptionHandler	getNotificationExceptionHandler()
(package private) ZObject	getReaper()
Thread.UncaughtExceptionHandler	getUncaughtExceptionHandler()
private void	initSlots()
boolean	isActive()
(package private) void	pendConnection(String addr, Ctx.Endpoint endpoint, Pipe[] pipes)
(package private) boolean	registerEndpoint(String addr, Ctx.Endpoint endpoint)
(package private) void	sendCommand(int tid, Command command)
boolean	set(int option, int optval)
void	setNotificationExceptionHandler(Thread.UncaughtExceptionHandler handler)	In Poller.run(), some non-fatal exceptions can be thrown.
void	setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler)	Set the handler invoked when a Poller abruptly terminates due to an uncaught exception.
(package private) final void	shutdown()
void	terminate()
(package private) boolean	unregisterEndpoint(String addr, SocketBase socket)
(package private) void	unregisterEndpoints(SocketBase socket)

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

WAIT_FOREVER

private static final int WAIT_FOREVER

See Also:

• Constant Field Values

active

private boolean active

sockets

private final List<SocketBase> sockets

emptySlots

private final Deque<Integer> emptySlots

starting

private final AtomicBoolean starting

terminating

private boolean terminating

slotSync

private final Lock slotSync

selectors

private final List<Selector> selectors

reaper

private Reaper reaper

ioThreads

private final List<IOThread> ioThreads

slotCount

private int slotCount

slots

private IMailbox[] slots

termMailbox

private final Mailbox termMailbox

endpoints

private final Map<String, Ctx.Endpoint> endpoints

endpointsSync

private final Lock endpointsSync

maxSocketId

private static AtomicInteger maxSocketId

maxSockets

private int maxSockets

ioThreadCount

private int ioThreadCount

blocky

private boolean blocky

optSync

private final Lock optSync

selectorSync

private final Lock selectorSync

TERM_TID

static final int TERM_TID

See Also:

• Constant Field Values

REAPER_TID

private static final int REAPER_TID

See Also:

• Constant Field Values

pendingConnections

private final MultiMap<String, Ctx.PendingConnection> pendingConnections

ipv6

private boolean ipv6

errno

private final Errno errno

exhandler

private Thread.UncaughtExceptionHandler exhandler

exnotification

private Thread.UncaughtExceptionHandler exnotification

forwardHolder

private Ctx.ChannelForwardHolder forwardHolder

Constructor Details

Ctx

public Ctx()

Method Details

destroy

private void destroy()
              throws IOException

Throws:

IOException

isActive

public boolean isActive()

Returns:

false if terminate()terminate() has been called.

checkTag

@Deprecated
public boolean checkTag()

Deprecated.

use isActive() instead

Returns:

false if terminate()terminate() has been called.

terminate

public void terminate()

shutdown

final void shutdown()

setUncaughtExceptionHandler

public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler)

Set the handler invoked when a Poller abruptly terminates due to an uncaught exception.

It default to the value of Thread.getDefaultUncaughtExceptionHandler()

Parameters:

handler - The object to use as this thread's uncaught exception handler. If null then this thread has no explicit handler.

getUncaughtExceptionHandler

public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()

Returns:

The handler invoked when a Poller abruptly terminates due to an uncaught exception.

setNotificationExceptionHandler

public void setNotificationExceptionHandler(Thread.UncaughtExceptionHandler handler)

In Poller.run(), some non-fatal exceptions can be thrown. This handler will be notified, so they can be logged.

Default to Throwable.printStackTrace()

Parameters:

handler - The object to use as this thread's handler for recoverable exceptions notifications.

getNotificationExceptionHandler

public Thread.UncaughtExceptionHandler getNotificationExceptionHandler()

Returns:

The handler invoked when a non-fatal exceptions is thrown in zmq.poll.Poller#run()

set

public boolean set(int option,
 int optval)

get

public int get(int option)

createSocket

public SocketBase createSocket(int type)

initSlots

private void initSlots()

destroySocket

void destroySocket(SocketBase socket)

createSelector

public Selector createSelector()

closeSelector

public boolean closeSelector(Selector selector)

getReaper

ZObject getReaper()

sendCommand

void sendCommand(int tid,
 Command command)

chooseIoThread

IOThread chooseIoThread(long affinity)

registerEndpoint

boolean registerEndpoint(String addr,
 Ctx.Endpoint endpoint)

unregisterEndpoint

boolean unregisterEndpoint(String addr,
 SocketBase socket)

unregisterEndpoints

void unregisterEndpoints(SocketBase socket)

findEndpoint

Ctx.Endpoint findEndpoint(String addr)

pendConnection

void pendConnection(String addr,
 Ctx.Endpoint endpoint,
 Pipe[] pipes)

connectPending

void connectPending(String addr,
 SocketBase bindSocket)

connectInprocSockets

private void connectInprocSockets(SocketBase bindSocket,
 Options bindOptions,
 Ctx.PendingConnection pendingConnection,
 Ctx.Side side)

errno

public Errno errno()

forwardChannel

int forwardChannel(SelectableChannel channel)

Forward a channel in a monitor socket.

Parameters:

channel - a channel to forward

Returns:

the handle of the channel to be forwarded, used to retrieve it in getForwardedChannel(Integer)

getForwardedChannel

SelectableChannel getForwardedChannel(Integer handle)

Retrieve a channel, using the handle returned by forwardChannel(SelectableChannel). As WeakReference are used, if the channel was discarded and a GC ran, it will not be found and this method will return null.

Parameters:

handle -

Returns:

cleanForwarded

private void cleanForwarded()

Clean all empty references