alluxio

Class Registry<T extends Server<U>,U>

java.lang.Object

alluxio.Registry<T,U>

Type Parameters:

T - the type of the Server

U - the type of the Server.start(T) method options

Direct Known Subclasses:

MasterRegistry, WorkerRegistry

@ThreadSafe
public class Registry<T extends Server<U>,U>
extends Object

Class for registering individual Servers that run within an Alluxio process. The intended use of this class is for the Alluxio process to register the individual Servers using an instance of this class. The registry is passed as an argument to constructors of individual Servers who are expected to add themselves to the registry. The reason for using an instance as opposed to a static class is to enable dependency injection in tests.

Constructor Summary

Constructors

Constructor and Description
Registry() Creates a new instance of Registry.

Method Summary

Modifier and Type	Method and Description
<W extends T> void	add(Class<W> clazz, T server) Registers a canonical mapping of the type to the server instance.
<W extends T> void	addAlias(Class<W> clazz, T server) Registers a server instance under an alias type.
void	close() Closes all Servers in reverse dependency order.
<W extends T> W	get(Class<W> clazz) Convenience method for calling get(Class, int) with a default timeout.
<W extends T> W	get(Class<W> clazz, int timeoutMs) Attempts to look up the Server for the given class.
<W extends T> W	getCanonical(Class<W> type) Convenience method for getCanonical(Class, int) with default timeout.
<W extends T> W	getCanonical(Class<W> type, int timeoutMs) Gets the server registered with the canonical type.
List<T>	getServers()
void	start(U options) Starts all Servers in dependency order.
void	stop() Stops all Servers in reverse dependency order.

Methods inherited from class java.lang.Object

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

Constructor Detail

Registry

public Registry()

Creates a new instance of Registry.

Method Detail

get

public <W extends T> W get(Class<W> clazz)

Convenience method for calling get(Class, int) with a default timeout.

Type Parameters:

W - the type of the Server to get

Parameters:

clazz - the class of the Server to get

Returns:

the Server instance

get

public <W extends T> W get(Class<W> clazz,
                           int timeoutMs)

Attempts to look up the Server for the given class. Because Servers can be looked up and added to the registry in parallel, the lookup is retried until the given timeout period has elapsed.

Type Parameters:

W - the type of the Server to get

Parameters:

clazz - the class of the Server to get

timeoutMs - timeout for looking up the server

Returns:

the Server instance

See Also:

if alias mappings should be ignored

getCanonical

public <W extends T> W getCanonical(Class<W> type)

Convenience method for getCanonical(Class, int) with default timeout.

Type Parameters:

W - server type

Parameters:

type - canonical type

Returns:

server instance

getCanonical

public <W extends T> W getCanonical(Class<W> type,
                                    int timeoutMs)

Gets the server registered with the canonical type. Aliases added via addAlias(Class, Server) are not considered.

Type Parameters:

W - the type

Parameters:

type - the canonical type

timeoutMs - time before giving up the lookup

Returns:

the server instance

See Also:

get(Class, int)

add

public <W extends T> void add(Class<W> clazz,
                              T server)

Registers a canonical mapping of the type to the server instance. Overrides any existing mappings.

Type Parameters:

W - the type of the Server to add

Parameters:

clazz - the class of the Server to add

server - the Server to add

See Also:

addAlias(Class, Server)

addAlias

public <W extends T> void addAlias(Class<W> clazz,
                                   T server)

Registers a server instance under an alias type.
Typically, a server instance should be registered with only one type. When it's necessary to register the instance under a super type as well, an alias mapping should be used. The alias mappings are consulted when retrieving the server instances, but are not used to start or stop the server instances.

Type Parameters:

W - the type of the server

Parameters:

clazz - the alias type

server - the Server to add

Throws:

IllegalArgumentException - when the server has not yet been registered under a canonical name with add(Class, Server), or a canonical mapping already exists for the same type

See Also:

add(Class, Server)

getServers

public List<T> getServers()

Returns:

a list of all the registered Servers, order by dependency relation

start

public void start(U options)
           throws IOException

Starts all Servers in dependency order. If A depends on B, A is started before B. If a Server fails to start, already-started Servers will be stopped.

Parameters:

options - the start options

Throws:

IOException

stop

public void stop()
          throws IOException

Stops all Servers in reverse dependency order. If A depends on B, A is stopped before B.

Throws:

IOException

close

public void close()
           throws IOException

Closes all Servers in reverse dependency order. If A depends on B, A is closed before B.

Throws:

IOException