# OpenORB 1.3.1: Interface ServerManager

## org.openorb.net
Interface ServerManager

All Known Implementing Classes:
  ServerManagerImpl

public interface ServerManager

This class is the controller for most server side operations. It is responsible for registration and thread management for server protocols and channels, dispatch and thread management for requests, object reference construction and generates the adapter managers allowing flow control for adapters.

Author:
  Unknown

Inner Class Summary
`static interface` `ServerManager.AdapterManager` This is the interface for an object adapter manager.

Method Summary
`void` `channel_reaper()` This fuction runs in a separate thread and cleans up any channels which are not used for a long time.
`ServerManager.AdapterManager` `create_adapter_manager()` Create an adapter manager.
`byte[]` `create_cacheable_object_key(boolean use_suid, byte[][] parts)` This function is used by adapters to generate a key which will participate in adapter lookup short-circuiting.
`void` `enqueue_request(ServerRequest request)` Begin dispatch sequence for incoming request.
`byte[][]` `extract_cacheable_object_key(byte[] object_key)` Extract the component parts of a cacheable object_key.
`ObjectAdapter` `find_adapter(byte[] object_key)` This function finds an adapter for the specified object id.
`java.lang.Object[]` `get_protocol_ids()` Return the array of registered protocols.
`boolean` `is_cacheable_object_key(byte[] object_key)` Returns true if the given object_key can be used in the cache.
`boolean` `is_local_cacheable_object_key(byte[] object_key)` Returns true if the given object_key is cacheable and was created by this server.
`boolean` `is_suid_object_key(byte[] object_key)` Returns true if the given object key has a persistent target.
`ORB` `orb()`
`void` `protocol_listening(ServerProtocol protocol)` This is called when a server protocol begins listening.
`void` `protocol_not_listening(ServerProtocol protocol, boolean paused)` This is called when a server protocol is no longer listening.
`void` `register_adapter(byte[] aid, ObjectAdapter adapter)` Register an adapter.
`void` `register_channel(ServerChannel channel)` This operation occours when a protocol accepts a new incoming channel.
`void` `register_protocol(int profile_tag, ServerProtocol protocol)` Register a server protocol.
`boolean` `serve_request(boolean wait)` This is called from orb.perform_work, it serves a single request.
`void` `setMaxManagerHeldRequests(int maxManagerHeldRequests)` Maximum number of requests which may be held by an adapter in the HOLDING state.
`void` `setMaxQueueSize(int maxQueueSize)` Set maximum queue size.
`void` `setThreadPoolLimits(int min, int max)` Set thread pool size ranges.
`void` `shutdown(boolean wait_for_complete)` Shutdown the server side.
`void` `startup(boolean block, boolean allowPool)` Start up the server.
`void` `unregister_adapter(byte[] aid)` Unregister an adapter.
`void` `unregister_channel(ServerChannel channel)` Called when a channel enters the closed state.
`boolean` `work_pending()` Returns true if there are requests waiting in the incomming request queue for resources.

Method Detail

### orb

    public ORB orb()

  Returns:
    orb associated with the server manager.

### setThreadPoolLimits

    public void setThreadPoolLimits(int min,
                                    int max)

  Set thread pool size ranges. The thread pool size will be somewhere within this range, depending on load.
  Parameters:
    `min` - minimum size for thread pool. Must be greater than 0 and less than max.
    `max` - maximum thread pool size. If this is 0 then requests will only be processed when the orb.perform_work function is called. Must be greater than 0.

### setMaxQueueSize

    public void setMaxQueueSize(int maxQueueSize)

  Set maximum queue size. If the queue grows to this size then new incoming requests will be rejected with a TRANSIENT exception. Changing this value downwards will not result in queued requests being destroyed.
  Parameters:
    `maxQueueSize` - maximum queue size. Must be greater than 1. Values should be several times the maximum thread pool size.

### setMaxManagerHeldRequests

    public void setMaxManagerHeldRequests(int maxManagerHeldRequests)

  Maximum number of requests which may be held by an adapter in the HOLDING state. Changes to this value will only affect newly created object adapters.
  Parameters:
    `maxAdapterHeldRequests` - ceiling on adapter held requests. Individial adapter managers may modify this value downwards. Use 0 to dissallow the adapter holding state, and Integer.MAX_VALUE for no limit.

### create_cacheable_object_key

    public byte[] create_cacheable_object_key(boolean use_suid,
                                              byte[][] parts)

  This function is used by adapters to generate a key which will participate in adapter lookup short-circuiting.

### extract_cacheable_object_key

    public byte[][] extract_cacheable_object_key(byte[] object_key)

  Extract the component parts of a cacheable object_key. Returns null if is_cacheable_object_key would return false.

### is_cacheable_object_key

    public boolean is_cacheable_object_key(byte[] object_key)

  Returns true if the given object_key can be used in the cache.

### is_suid_object_key

    public boolean is_suid_object_key(byte[] object_key)

  Returns true if the given object key has a persistent target.

### is_local_cacheable_object_key

    public boolean is_local_cacheable_object_key(byte[] object_key)

  Returns true if the given object_key is cacheable and was created by this server.

### register_protocol

    public void register_protocol(int profile_tag,
                                  ServerProtocol protocol)

  Register a server protocol. This registers the protocol for purposes of constructing IORs. When the protocol begins listening it should call protocol_listening.

  If multiple protocols are registered with the same tag value, or a profile is registered with multiple tag values then the constructed IOR will contain multiple profiles, one from each distinct registered protocol/tag pair. Registering the same protocol with the same tag more than once will not result in multiple profiles.
  Parameters:
    `profile_tag` - Profile tag of IOR consturcted with the protocol.
    `protocol` - The server protocol.

### get_protocol_ids

    public java.lang.Object[] get_protocol_ids()

  Return the array of registered protocols.

### protocol_listening

    public void protocol_listening(ServerProtocol protocol)

  This is called when a server protocol begins listening. Thread resources are allocated to call the listen function regularly.
  Parameters:
    `protocol` - The server protocol.

### protocol_not_listening

    public void protocol_not_listening(ServerProtocol protocol,
                                       boolean paused)

  This is called when a server protocol is no longer listening. It stops getting serviced by the pool thread.
  Parameters:
    `protocol` - The server protocol.
    `paused` - If true when the server side is shut down close will still be called on the protocol.

### register_channel

    public void register_channel(ServerChannel channel)

  This operation occours when a protocol accepts a new incoming channel.

### unregister_channel

    public void unregister_channel(ServerChannel channel)

  Called when a channel enters the closed state. Returns once all channel threads have completed their work cycles.

### channel_reaper

    public void channel_reaper()

  This fuction runs in a separate thread and cleans up any channels which are not used for a long time.

### find_adapter

    public ObjectAdapter find_adapter(byte[] object_key)

  This function finds an adapter for the specified object id. If an adapter for an object with the given object id cannot be found this returns null. This varient of the find_adapter function is used by local bindings. It ignores the state of the adapter manager and any single threading policies, requests are held only if the target adapter or one of it's ancestors is in the process of being destroyed.
  Returns:
    The adapter specified in the object key.

### register_adapter

    public void register_adapter(byte[] aid,
                                 ObjectAdapter adapter)

  Register an adapter. If the specified adapter is already registered no change occours. This will occour automaticaly for child adapters of some root adapter.

### unregister_adapter

    public void unregister_adapter(byte[] aid)

  Unregister an adapter. If the specified adapter is not registered no change occours. If an adapter throws an AdapterDestroyed exception it must eventualy call this function to continue processing the held requests.

### create_adapter_manager

    public ServerManager.AdapterManager create_adapter_manager()

  Create an adapter manager.

### enqueue_request

    public void enqueue_request(ServerRequest request)

  Begin dispatch sequence for incoming request. This will enqueue the request and return immediatly.

### work_pending

    public boolean work_pending()

  Returns true if there are requests waiting in the incomming request queue for resources.

### serve_request

    public boolean serve_request(boolean wait)

  This is called from orb.perform_work, it serves a single request.
  Returns:
    true if a request was served, false if the queue is empty

### startup

    public void startup(boolean block,
                        boolean allowPool)

  Start up the server.
  Parameters:
    `block` - true if this funtion should not return until the server is shut down.
    `allowPool` - true if the thread pool is allowed. Once a call the thread pool has been started it cannot be dissallowed in the future by calling this with a false.

### shutdown

    public void shutdown(boolean wait_for_complete)

  Shutdown the server side. All new incoming requests will be rejected.
  Parameters:
    `wait_for_complete` - If true wait until all channels have closed and incomming requests have finished processing. If false all active requests will be canceled and the function will return once connections have shutdown.