Skip to content

Latest commit

 

History

History
196 lines (158 loc) · 6.56 KB

USAGE.md

File metadata and controls

196 lines (158 loc) · 6.56 KB
Raw

Using the rsp client

There are 3 modules you can import from this package: Client, Protocol, ServerState.

Protocol

Defines the object types used in communication with the server. Some of these objects are also used as parameters or returned by the client methods. Refer to this file for a complete list of definitions. This should mirror the definitions on the server side here.

ServerState

Defines constants representing the states a server can be in - including both the state of the server itself and the state of the projects published to the server. See here for a complete list.

Client

The main part that takes care of all the communication. Most methods have a timeout by default, can be changed as an optional last parameter (in milliseconds).

Create a new client by using the constructor:

const client = new RSPClient('host', port);

Connection Handling

Initiate the connection:

client.connect();

Disconnect the client:

client.disconnect();

Shut down the RSP server (and disconnect the client):

client.shutdownServer();

Server Discovery

Search a path for suitable servers, resolves to an array of ServerBean objects, see Protocol for definition:

client.findServerBeans('path');

Send notification to the RSP to add a directory to its discovery paths. Discovery paths are locations RSP will scan for servers. See events for async handling.

client.addDiscoveryPathAsync('path');

Synchronous version of adding discovery paths, resolves to a DiscoveryPath object, see Protocol for definition:

client.addDiscoveryPathSync('path');

Send notification to the RSP to remove a directory from its discovery paths.

client.removeDiscoveryPathAsync('path' | path: DiscoveryPath);

Synchronous version of removing discovery paths, resolves to a DiscoveryPath object of the path that got removed

client.removeDiscoveryPathAsync('path' | path: DiscoveryPath);

Get all currently used discovery paths, resolves to an array of DiscoveryPath objects:

client.getDiscoveryPaths();

Manipulating Server Model

Send a notification to create a server from a path to its root directory or from a ServerBean object with given id. See events for async handling. Resolves to a Status object, see Protocol for definition:

client.createServerAsync('path' | bean: ServerBean, 'id');

Synchronous version of creating a server, resolves to a ServerHandle object:

client.createServerSync('path' | bean: ServerBean, 'id');

Send a notification to delete a server defined by a ServerHandle:

client.deleteServerAsync(serverHandle: ServerHandle);

Synchronous version of deleting a server, resolves to the ServerHandle representing the removed server:

client.deleteServerSync(serverHandle: ServerHandle);

Get handles for all servers, resolves to an array of ServerHandle objects:

client.getServerHandles();

Get all supported server types, resolves to an array of ServerType objects:

client.getServerTypes();

Get required or optional attributes of a particular server type, resolves to an Attributes object:

client.getServerTypeRequiredAttributes(type: ServerType);
client.getServerTypeOptionalAttributes(type: ServerType);

Launching Servers

Get possible launch modes for a server type, resolves to an array of ServerLaunchMode objects:

client.getServerLaunchModes(type: ServerType);

Get required or optional launch attributes of a particular server in a particular mode, resolves to an Attributes object:

client.getRequiredLaunchAttributes(request: LaunchAttributesRequest);
client.getOptionalLaunchAttributes(request: LaunchAttributesRequest);

Get the command usable to manually start a server from cli, resolves to a CommandLineDetails object:

client.getServerLaunchCommand(launchParameters: LaunchParameters);

Notify RSP that the client is launching / has launched a server manually, resolves to a Status object:

client.serverStartingByClient(startingAttributes: ServerStartingAttributes);
client.serverStartingByClient(launchParameters: LaunchParameters);

Start a server asynchronously, resolves to a StartServerResponse object. See events for async handling:

client.startServerAsync(launchParameters: LaunchParameters);

Start a server synchronously, resolves to a ServerStateChange object representing the event of server starting up:

client.startServerSync(launchParameters: LaunchParameters);

Stop a server asynchronously, resolves to a Status object.

client.stopServerAsync(stopAttributes: StopServerAttributes);

Stop a server synchronously, resolves to a ServerStateChange object representing the event of server stopping:

client.stopServerSync(stopAttributes: StopServerAttributes);

Events

The asynchronous methods use several events to handle the response from the server. The client has the following methods to subscribe to these events.

// handle adding discovery paths
client.onDiscoveryPathAdded(listener: (arg: DiscoveryPath) => {
    // your logic here
});

// handle removing discovery paths
client.onDiscoveryPathRemoved(listener: (arg: DiscoveryPath) => {
    // your logic here
});

// handle adding servers
client.onServerAdded(listener: (arg: ServerHandle) => {
    // your logic here
});

// handle removing servers
client.onServerRemoved(listener: (arg: ServerHandle) => {
    // your logic here
});

// handle server state changes, useful for starting or stopping servers
client.onServerStateChange(listener: (arg: ServerStateChange) => {
    // your logic here
});

// handle incoming output from a server
client.onServerOutputAppended(listener: (arg: ServerProcessOutput) => {
    // your logic here
});

// handle server's attributes changing
client.onServerAttributeChange(listener: (arg: ServerHandle) => {
    // your logic here
});

// handle server process creation
client.onServerProcessCreated(listener: (arg: ServerProcess) => {
    // your logic here
});

// handle server process termination
client.onServerProcessTerminated(listener: (arg: ServerProcess) => {
    // your logic here
});