com.perforce.p4java.impl.mapbased.rpc
Class NtsServerImpl

java.lang.Object
  com.perforce.p4java.impl.mapbased.server.Server
      com.perforce.p4java.impl.mapbased.rpc.RpcServer
          com.perforce.p4java.impl.mapbased.rpc.NtsServerImpl

All Implemented Interfaces:

IServerControl, IOptionsServer, IServer

public class NtsServerImpl
extends RpcServer

NTS (non-thread-safe) version of the P4Java RPC implementation.

By "not thread safe" we really mean that it's up to the consumer to synchronize calls to the server object; if you want a thread-safe implementation see the OneShotServerImpl class (which is marginally slower but thread safe). The intention here is that if you can guarantee that only one thread at a time will access the connect / disconnect and exec series of methods on this object, you can use this class, which will typically have lower network connection latency than the OneShotServerImpl implementation; overll throughput, though, should be roughly comparable for both implementations over time.

Field Summary

static boolean	DEFAULT_STATUS True IFF this is the default implementation.
protected RpcPacketDispatcher	dispatcher
static String	IMPL_COMMENTS Implementation-specific comments (dependencies, limitations, etc.).
static int	MINIMUM_SUPPORTED_SERVER_LEVEL The minimum Perforce server level required by this implementation.
static String	PROTOCOL_NAME The specific protocol name to be used in URIs for this implementation.
protected ProtocolCommand	protocolSpecs
protected RpcConnection	rpcConnection
static String	SCREEN_NAME The short-form name (display name) of this implementation.
static String	SSL_PROTOCOL_NAME The specific SSL protocol name to be used in URIs for this implementation.
static String	TRACE_PREFIX What we use as a P4JTracer trace prefix for methods here.

Fields inherited from class com.perforce.p4java.impl.mapbased.rpc.RpcServer

applicationName, authCounter, authFileLockDelay, authFileLockTry, authFileLockWait, clientApiLevel, clientTrust, cmdMapArgs, connectionStart, DEFAULT_CLIENT_API_LEVEL, DEFAULT_PROG_NAME, DEFAULT_PROG_VERSION, DEFAULT_SERVER_API_LEVEL, IMPL_TYPE, localHostName, relaxCmdNameValidationChecks, RPC_ENABLE_STREAMS, RPC_ENV_CWD_KEY, RPC_ENV_NOCLIENT_SPEC, RPC_ENV_NOHOST_SPEC, RPC_ENV_NOUSER_SPEC, RPC_ENV_OS_NAME_KEY, RPC_ENV_UNIX_SPEC, RPC_ENV_WINDOWS_PREFIX, RPC_ENV_WINDOWS_SPEC, RPC_TAGS_USED, RPC_TMP_CONVERTER_KEY, RPC_TMP_OUTFILE_STREAM_KEY, rpcServerAddress, secretKeys, serverApiLevel, serverId, serverProtocolMap, serverStats, ticketsFilePath, trustFilePath

Fields inherited from class com.perforce.p4java.impl.mapbased.server.Server

ATTRIBUTE_STREAM_MAP_KEY, authTickets, caseSensitive, charset, charsetName, client, clientName, clientUnsetName, commandCallback, connected, CORE_AUTH_FAIL_STRING_1, CORE_AUTH_FAIL_STRING_2, CORE_AUTH_FAIL_STRING_3, CORE_AUTH_FAIL_STRING_4, DEFAULT_STATUS_FIELD_NAME, enableProgress, enableTracking, ignoreFileName, IMPL_COMMENTS_FIELD_NAME, IMPL_TYPE_FIELD_NAME, IN_MAP_USE_TAGS_KEY, loginOnConnect, MINIMUM_SUPPORTED_SERVER_LEVEL_FIELD_NAME, minumumSupportedServerVersion, nextCmdCallBackKey, nextProgressCallbackKey, nonCheckedSyncs, P4IGNORE_ENV_VAR, P4TICKETS_DEFAULT_OTHER, P4TICKETS_DEFAULT_WINDOWS, P4TICKETS_ENV_VAR, P4TRUST_DEFAULT_OTHER, P4TRUST_DEFAULT_WINDOWS, P4TRUST_ENV_VAR, password, progressCallback, props, PROTOCOL_NAME_FIELD_NAME, quietMode, rand, rsh, runningOnWindows, SCREEN_NAME_FIELD_NAME, secure, serverAddress, serverHost, serverInfo, serverPort, serverVersion, setupOnConnect, ssoCallback, ssoKey, status, tmpDirName, UNKNOWN_SERVER_HOST, UNKNOWN_SERVER_PORT, UNKNOWN_SERVER_VERSION, usageOptions, useAuthMemoryStore, userName

Constructor Summary

NtsServerImpl()

Method Summary

void	connect() Try to establish an actual RPC connection to the target Perforce server.
void	disconnect() Try to cleanly disconnect from the Perforce server at the other end of the current connection (with the emphasis on "cleanly").
Map<String,Object>[]	execInputStringMapCmd(String cmdName, String[] cmdArgs, String inString) Issue an arbitrary P4Java command to the Perforce server and return the results as a map.
List<Map<String,Object>>	execInputStringMapCmdList(String cmdName, String[] cmdArgs, String inString) Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps.
List<Map<String,Object>>	execInputStringMapCmdList(String cmdName, String[] cmdArgs, String inString, IFilterCallback filterCallback) Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps.
InputStream	execInputStringStreamCmd(String cmdName, String[] cmdArgs, String inString) Issue an arbitrary P4Java command to the Perforce server and return the results as a stream.
void	execInputStringStreamingMapCmd(String cmdName, String[] cmdArgs, String inString, IStreamingCallback callback, int key) Issue a streaming map command to the Perforce server, using an optional string for any input expected by the server (such as label or job specs, etc.).
void	execInputStringStreamingMapComd(String cmdName, String[] cmdArgs, String inString, IStreamingCallback callback, int key) Deprecated. As of release 2013.1, replaced by execInputStringStreamingMapCmd(java.lang.String, java.lang.String[], java.lang.String, com.perforce.p4java.server.callback.IStreamingCallback, int)
Map<String,Object>[]	execMapCmd(String cmdName, String[] cmdArgs, Map<String,Object> inMap) Issue an arbitrary P4Java command to the Perforce server and return the results as a map.
protected Map<String,Object>[]	execMapCmd(String cmdName, String[] cmdArgs, Map<String,Object> inMap, String inString, boolean ignoreCallbacks, IStreamingCallback callback, int callbackKey, IFilterCallback filterCallback)
List<Map<String,Object>>	execMapCmdList(String cmdName, String[] cmdArgs, Map<String,Object> inMap) Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps.
List<Map<String,Object>>	execMapCmdList(String cmdName, String[] cmdArgs, Map<String,Object> inMap, IFilterCallback filterCallback) Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps.
protected List<Map<String,Object>>	execMapCmdList(String cmdName, String[] cmdArgs, Map<String,Object> inMap, String inString, boolean ignoreCallbacks, IStreamingCallback callback, int callbackKey, IFilterCallback filterCallback)
Map<String,Object>[]	execQuietMapCmd(String cmdName, String[] cmdArgs, Map<String,Object> inMap) Issue an arbitrary P4Java command to the Perforce server and return the results as a map without invoking any command callbacks.
List<Map<String,Object>>	execQuietMapCmdList(String cmdName, String[] cmdArgs, Map<String,Object> inMap) Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps without invoking any command callbacks.
InputStream	execQuietStreamCmd(String cmdName, String[] cmdArgs) Issue an arbitrary P4Java command to the Perforce server and get the results as a stream without invoking any command callbacks.
InputStream	execStreamCmd(String cmdName, String[] cmdArgs) Issue an arbitrary P4Java command to the Perforce server and get the results as a stream.
InputStream	execStreamCmd(String cmdName, String[] cmdArgs, Map<String,Object> inMap) Issue an arbitrary P4Java command to the Perforce server and get the results as a stream.
protected InputStream	execStreamCmd(String cmdName, String[] cmdArgs, Map<String,Object> inMap, String inString, boolean ignoreCallbacks) Note that this method does the access / request exception processing here rather than passing things up the stack; we may introduce an extended version of this method to take the map array as an output parameter in later releases.
void	execStreamingMapCommand(String cmdName, String[] cmdArgs, Map<String,Object> inMap, IStreamingCallback callback, int key) Issue a streaming map command to the Perforce server, using an optional map for any input expected by the server (such as label or job specs, etc.).
RpcConnection	getRpcConnection()
ServerStatus	init(String host, int port, Properties props) Shorthand for the options-based init() above, but with a null opts arg.
ServerStatus	init(String host, int port, Properties props, UsageOptions opts) Shorthand for the options-based init() above, but with a fasle secure arg.
ServerStatus	init(String host, int port, Properties props, UsageOptions opts, boolean secure) Shorthand for the options-based init() above, but with a fasle secure arg.
ServerStatus	init(String host, int port, Properties props, UsageOptions opts, boolean secure, String rsh) Initialize the server.
boolean	setCharsetName(String charsetName) Need to override this method at this level as we keep the connection open here...
void	setRpcConnection(RpcConnection rpcConnection)
protected ExternalEnv	setupCmd(String cmdName, String[] cmdArgs, Map<String,Object> inMap, boolean ignoreCallbacks, int cmdCallBackKey, boolean isStream) Factors out the command setup that's common to stream and map commands.

Methods inherited from class com.perforce.p4java.impl.mapbased.rpc.RpcServer

addTrust, addTrust, addTrust, checkFingerprint, composeAuthTicketEntryKey, getApplicationName, getAuthCounter, getAuthTicket, getClientApiLevel, getClientNameForEnv, getErrorOrInfoStr, getErrorStr, getGenericCode, getHostForEnv, getInfoStr, getLanguageForEnv, getOsTypeForEnv, getPerfMonitor, getRpcPacketFieldRule, getRpcServerAddress, getSecretKey, getSecretKey, getServerAddress, getServerHostPort, getServerId, getSeverityCode, getTicketsFilePath, getTrust, getTrustFilePath, getTrusts, getTrusts, getUserForEnv, isAuthFail, isInfoMessage, isLoginNotRequired, isRelaxCmdNameValidationChecks, loadFingerprint, loadFingerprints, loadTicket, processCmdCallbacks, removeTrust, removeTrust, saveCurrentTicket, saveFingerprint, saveTicket, saveTicket, setApplicationName, setAuthTicket, setClientApiLevel, setPerfMonitor, setRelaxCmdNameValidationChecks, setRpcServerAddress, setSecretKey, setSecretKey, setServerId, setTicketsFilePath, setTrustFilePath, supportsSmartMove, useTags, writeInPlace

Methods inherited from class com.perforce.p4java.impl.mapbased.server.Server

changePassword, createBranchSpec, createClient, createDepot, createJob, createLabel, createProtectionEntries, createStream, createTriggerEntries, createUser, createUser, createUserGroup, createUserGroup, deleteBranchSpec, deleteBranchSpec, deleteClient, deleteClient, deleteCounter, deleteDepot, deleteJob, deleteKey, deleteLabel, deleteLabel, deletePendingChangelist, deletePendingChangelist, deleteProperty, deleteStream, deleteUser, deleteUser, deleteUserGroup, deleteUserGroup, duplicateRevisions, execMapCmd, execMapCmdList, execStreamCmd, fixJobs, fixJobs, getAuthTicket, getBranchSpec, getBranchSpec, getBranchSpecs, getBranchSpecs, getChangelist, getChangelist, getChangelistDiffs, getChangelistDiffs, getChangelistDiffsStream, getChangelistFiles, getChangelists, getChangelists, getChangelists, getCharsetName, getClient, getClient, getClientName, getClients, getClients, getClientTemplate, getClientTemplate, getClientTemplate, getCounter, getCounter, getCounters, getCounters, getCounters, getCurrentClient, getDbSchema, getDefaultP4TicketsFile, getDefaultP4TrustFile, getDepot, getDepotFiles, getDepotFiles, getDepots, getDirectories, getDirectories, getDiskSpace, getExportRecords, getExportRecords, getExtendedFiles, getExtendedFiles, getFileAnnotations, getFileAnnotations, getFileContents, getFileContents, getFileDiffs, getFileDiffs, getFileDiffsStream, getFileSizes, getFixes, getFixList, getIgnoreFileName, getInfoServerAddress, getInterchanges, getInterchanges, getInterchanges, getInterchanges, getJob, getJobs, getJobs, getJobSpec, getKey, getKeys, getKnownCharsets, getLabel, getLabels, getLabels, getLoginStatus, getLogTail, getMatchingLines, getMatchingLines, getOpenedFiles, getOpenedFiles, getPreferredPathArray, getPreferredPathArray, getProperties, getProperty, getProtectionEntries, getProtectionEntries, getProtectionsTable, getRandomInt, getReviewChangelists, getReviews, getReviews, getRevisionHistory, getRevisionHistory, getServerFileDiffs, getServerInfo, getServerProcesses, getServerProcesses, getServerVersion, getServerVersionNumber, getShelvedFiles, getSSOCallback, getSSOKey, getStatus, getStream, getStream, getStreamingExportRecords, getStreamIntegrationStatus, getStreams, getSubmittedIntegrations, getSubmittedIntegrations, getTriggerEntries, getTriggersTable, getUsageOptions, getUser, getUserGroup, getUserGroups, getUserGroups, getUserName, getUsers, getUsers, getWorkingDirectory, guardNull, handleErrorStr, handleFileErrorStr, handleFileReturn, handleFileReturn, handleIntegrationFileReturn, handleIntegrationFileReturn, isCaseSensitive, isConnected, isDontWriteTicket, isEnableProgress, isEnableTracking, isNonCheckedSyncs, isQuietMode, isRunningOnWindows, isSecure, isUnicode, journalWait, login, login, login, login, login, logout, logout, moveFile, moveFile, obliterateFiles, parseVersionString, populatePathArray, processInterchangeMaps, registerCallback, registerProgressCallback, registerSSOCallback, reload, renameUser, searchJobs, setAuthTicket, setClientName, setCounter, setCounter, setCurrentClient, setEnableProgress, setEnableTracking, setFileAttributes, setFileAttributes, setIgnoreFileName, setKey, setNonCheckedSyncs, setProperty, setQuietMode, setSecure, setServerConfigurationValue, setUsageOptions, setUserName, setWorkingDirectory, showServerConfiguration, supportsUnicode, switchClientView, switchStreamView, tagFiles, tagFiles, unload, updateBranchSpec, updateClient, updateClient, updateClient, updateJob, updateLabel, updateProtectionEntries, updateStream, updateTriggerEntries, updateUser, updateUser, updateUserGroup, updateUserGroup, verifyFiles

Methods inherited from class java.lang.Object

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

Field Detail

SCREEN_NAME

public static final String SCREEN_NAME

The short-form name (display name) of this implementation.

See Also:

Constant Field Values

IMPL_COMMENTS

public static final String IMPL_COMMENTS

Implementation-specific comments (dependencies, limitations, etc.).

See Also:

Constant Field Values

PROTOCOL_NAME

public static final String PROTOCOL_NAME

The specific protocol name to be used in URIs for this implementation.

SSL_PROTOCOL_NAME

public static final String SSL_PROTOCOL_NAME

The specific SSL protocol name to be used in URIs for this implementation.

MINIMUM_SUPPORTED_SERVER_LEVEL

public static final int MINIMUM_SUPPORTED_SERVER_LEVEL

The minimum Perforce server level required by this implementation.

See Also:

Constant Field Values

DEFAULT_STATUS

public static final boolean DEFAULT_STATUS

True IFF this is the default implementation. There must be only one of these...

See Also:

Constant Field Values

TRACE_PREFIX

public static final String TRACE_PREFIX

What we use as a P4JTracer trace prefix for methods here.

See Also:

Constant Field Values

protocolSpecs

protected ProtocolCommand protocolSpecs

dispatcher

protected RpcPacketDispatcher dispatcher

rpcConnection

protected RpcConnection rpcConnection

Constructor Detail

NtsServerImpl

public NtsServerImpl()

Method Detail

init

public ServerStatus init(String host,
                         int port,
                         Properties props,
                         UsageOptions opts,
                         boolean secure,
                         String rsh)
                  throws ConfigException,
                         ConnectionException

Initialize the server. Basically defers to the superclass after setting up the required server version.

Parameters:

host - the Perforce server hostname or IP address as passed in to the factory method

port - the Perforce server port number as passed in to the factory method

props - the properties passed in to the factory method

opts - the UsageOptions object to be associated with the server object; if null, the server should construct a new default UsageOptions object.

secure - indicates whether the server is secure (SSL) or not.

rsh - the 'rsh' mode server launch command.

Returns:

the resulting status; should be ACTIVE unless otherwise specified

Throws:

ConfigException - if there's something wrong with the specified configuration or associated config files, etc.

ConnectionException - if the server is unreachable on initialization, and that unreachability is serious and unrecoverable (there are implementations that don't really do connections per se, so they may not consider this an error or even try connecting during initialisation).

See Also:

RpcServer.init(java.lang.String, int, java.util.Properties, com.perforce.p4java.option.UsageOptions, boolean)

init

public ServerStatus init(String host,
                         int port,
                         Properties props,
                         UsageOptions opts,
                         boolean secure)
                  throws ConfigException,
                         ConnectionException

Shorthand for the options-based init() above, but with a fasle secure arg.

Specified by:

init in interface IServerControl

Overrides:

init in class RpcServer

Parameters:

host - the Perforce server hostname or IP address as passed in to the factory method

port - the Perforce server port number as passed in to the factory method

props - the properties passed in to the factory method

opts - the UsageOptions object to be associated with the server object; if null, the server should construct a new default UsageOptions object.

Returns:

the resulting status; should be ACTIVE unless otherwise specified

Throws:

ConfigException - if there's something wrong with the specified configuration or associated config files, etc.

ConnectionException - if the server is unreachable on initialization, and that unreachability is serious and unrecoverable (there are implementations that don't really do connections per se, so they may not consider this an error or even try connecting during initialisation).

See Also:

RpcServer.init(java.lang.String, int, java.util.Properties, com.perforce.p4java.option.UsageOptions, boolean)

init

public ServerStatus init(String host,
                         int port,
                         Properties props,
                         UsageOptions opts)
                  throws ConfigException,
                         ConnectionException

Shorthand for the options-based init() above, but with a fasle secure arg.

Specified by:

init in interface IServerControl

Overrides:

init in class RpcServer

Parameters:

host - the Perforce server hostname or IP address as passed in to the factory method

port - the Perforce server port number as passed in to the factory method

props - the properties passed in to the factory method

opts - the UsageOptions object to be associated with the server object; if null, the server should construct a new default UsageOptions object.

Returns:

the resulting status; should be ACTIVE unless otherwise specified

Throws:

ConfigException - if there's something wrong with the specified configuration or associated config files, etc.

ConnectionException - if the server is unreachable on initialization, and that unreachability is serious and unrecoverable (there are implementations that don't really do connections per se, so they may not consider this an error or even try connecting during initialisation).

See Also:

RpcServer.init(java.lang.String, int, java.util.Properties, com.perforce.p4java.option.UsageOptions)

init

public ServerStatus init(String host,
                         int port,
                         Properties props)
                  throws ConfigException,
                         ConnectionException

Shorthand for the options-based init() above, but with a null opts arg.

Specified by:

init in interface IServerControl

Overrides:

init in class RpcServer

Parameters:

host - the Perforce server hostname or IP address as passed in to the factory method

port - the Perforce server port number as passed in to the factory method

Returns:

the resulting status; should be ACTIVE unless otherwise specified

Throws:

ConfigException - if there's something wrong with the specified configuration or associated config files, etc.

ConnectionException - if the server is unreachable on initialization, and that unreachability is serious and unrecoverable (there are implementations that don't really do connections per se, so they may not consider this an error or even try connecting during initialisation).

See Also:

RpcServer.init(java.lang.String, int, java.util.Properties)

connect

public void connect()
             throws ConnectionException,
                    AccessException,
                    RequestException,
                    ConfigException

Try to establish an actual RPC connection to the target Perforce server. Most of the actual setup work is done in the RpcConnection and RpcPacketDispatcher constructors, but associated gubbins such as auto login, etc., are done in the superclass.

Specified by:

connect in interface IServer

Overrides:

connect in class RpcServer

Throws:

ConnectionException - if the Perforce server is unreachable or is not connected.

AccessException - if the Perforce server denies access to the caller

RequestException - if the Perforce server encounters an error during its processing of the request

ConfigException - if local I/O exception occurs

See Also:

Server.connect()

disconnect

public void disconnect()
                throws ConnectionException,
                       AccessException

Try to cleanly disconnect from the Perforce server at the other end of the current connection (with the emphasis on "cleanly"). This should theoretically include sending a release2 message, but we don't always get the chance to do that.

Specified by:

disconnect in interface IServer

Overrides:

disconnect in class RpcServer

Throws:

ConnectionException

AccessException

See Also:

Server.disconnect()

setCharsetName

public boolean setCharsetName(String charsetName)
                       throws UnsupportedCharsetException

Need to override this method at this level as we keep the connection open here...

Specified by:

setCharsetName in interface IServer

Overrides:

setCharsetName in class Server

Parameters:

charsetName - charset name; if null, resets the charset to "no charset".

Returns:

true if the attempt to set the charset name succeeded; false otherwise. False will only be returned if the JVM doesn't support the charset. (an exception will be thrown if the server doesn't recognize it).

Throws:

UnsupportedCharsetException - if the Perforce server doesn't support or recognize the charset name.

See Also:

Server.setCharsetName(java.lang.String)

execMapCmd

public Map<String,Object>[] execMapCmd(String cmdName,
                                       String[] cmdArgs,
                                       Map<String,Object> inMap)
                                throws ConnectionException,
                                       AccessException,
                                       RequestException

Description copied from interface: IServer

Issue an arbitrary P4Java command to the Perforce server and return the results as a map.

This method is intended for low-level commands in the spirit and format of the p4 command line interpreter, and offers a simple way to issue commands to the associated Perforce server without the overhead of the more abstract Java interfaces and methods.

No guidance is given here on the format of the returned map; however, it produces the same output as the p4 command line interpreter in -G (Python map) mode.

Note that this method does not allow you to set "usage" options for the command; these may be added later. Note also that although option arguments passed to this method must be in a form recognized by the p4 command line interpreter, that does not mean the method is being implemented by the interpreter -- the actual implementation depends on the options used to get the server object in the first place from the server factory.

Specified by:

execMapCmd in interface IServer

Specified by:

execMapCmd in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inMap - an optional map to be sent to the server as standard input, using the Python map format (-G) form. You must remember to issue the relevant command-specific option to enable this if needed.

Returns:

a non-null Java Map of results; these results are as returned from issuing the command using the -G option with the p4 command line interpreter.

Throws:

ConnectionException - if the Perforce server is unreachable or is not connected.

AccessException - if the Perforce server denies access to the caller

RequestException - if the Perforce server encounters an error during its processing of the request

See Also:

Server.execMapCmd(java.lang.String, java.lang.String[], java.util.Map)

execMapCmdList

public List<Map<String,Object>> execMapCmdList(String cmdName,
                                               String[] cmdArgs,
                                               Map<String,Object> inMap)
                                        throws P4JavaException

Description copied from interface: IOptionsServer

Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps.

This method is intended for low-level commands in the spirit and format of the p4 command line interpreter, and offers a simple way to issue commands to the associated Perforce server without the overhead of the more abstract Java interfaces and methods.

No guidance is given here on the format of the returned map; however, it produces the same output as the p4 command line interpreter in -G (Python map) mode.

Note that this method does not allow you to set "usage" options for the command; these may be added later. Note also that although option arguments passed to this method must be in a form recognized by the p4 command line interpreter, that does not mean the method is being implemented by the interpreter -- the actual implementation depends on the options used to get the server object in the first place from the server factory.

Specified by:

execMapCmdList in interface IOptionsServer

Specified by:

execMapCmdList in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inMap - an optional map to be sent to the server as standard input, using the Python map format (-G) form. You must remember to issue the relevant command-specific option to enable this if needed.

Returns:

a non-null Java List of results; these results are as returned from issuing the command using the -G option with the p4 command line interpreter.

Throws:

P4JavaException - if an error occurs processing this method and its parameters.

See Also:

Server.execMapCmdList(java.lang.String, java.lang.String[], java.util.Map)

execMapCmdList

public List<Map<String,Object>> execMapCmdList(String cmdName,
                                               String[] cmdArgs,
                                               Map<String,Object> inMap,
                                               IFilterCallback filterCallback)
                                        throws P4JavaException

Description copied from interface: IOptionsServer

Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps.

This method is intended for low-level commands in the spirit and format of the p4 command line interpreter, and offers a simple way to issue commands to the associated Perforce server without the overhead of the more abstract Java interfaces and methods.

No guidance is given here on the format of the returned map; however, it produces the same output as the p4 command line interpreter in -G (Python map) mode.

Note that this method does not allow you to set "usage" options for the command; these may be added later. Note also that although option arguments passed to this method must be in a form recognized by the p4 command line interpreter, that does not mean the method is being implemented by the interpreter -- the actual implementation depends on the options used to get the server object in the first place from the server factory.

Specified by:

execMapCmdList in interface IOptionsServer

Specified by:

execMapCmdList in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inMap - an optional map to be sent to the server as standard input, using the Python map format (-G) form. You must remember to issue the relevant command-specific option to enable this if needed.

filterCallback - an optional filter callback to decide on skipping or keeping individual key/value pairs as part of the results map.

Returns:

a non-null Java List of results; these results are as returned from issuing the command using the -G option with the p4 command line interpreter.

Throws:

P4JavaException - if an error occurs processing this method and its parameters.

See Also:

Server.execMapCmdList(java.lang.String, java.lang.String[], java.util.Map, com.perforce.p4java.server.callback.IFilterCallback)

execQuietMapCmd

public Map<String,Object>[] execQuietMapCmd(String cmdName,
                                            String[] cmdArgs,
                                            Map<String,Object> inMap)
                                     throws ConnectionException,
                                            RequestException,
                                            AccessException

Description copied from interface: IServer

Issue an arbitrary P4Java command to the Perforce server and return the results as a map without invoking any command callbacks.

Basically equivalent to execMapCmd with temporary disabling of any ICommandCallback calls and / or listeners; this turns out to be useful for various reasons we won't go into here...

Specified by:

execQuietMapCmd in interface IServer

Specified by:

execQuietMapCmd in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inMap - an optional map to be sent to the server as standard input, using the Python map format (-G) form. You must remember to issue the relevant command-specific option to enable this if needed.

Returns:

a non-null Java Map of results; these results are as returned from issuing the command using the -G option with the p4 command line interpreter.

Throws:

ConnectionException - if the Perforce server is unreachable or is not connected.

RequestException - if the Perforce server encounters an error during its processing of the request

AccessException - if the Perforce server denies access to the caller

See Also:

Server.execQuietMapCmd(java.lang.String, java.lang.String[], java.util.Map)

execQuietMapCmdList

public List<Map<String,Object>> execQuietMapCmdList(String cmdName,
                                                    String[] cmdArgs,
                                                    Map<String,Object> inMap)
                                             throws P4JavaException

Description copied from interface: IOptionsServer

Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps without invoking any command callbacks.

Basically equivalent to execMapCmd with temporary disabling of any ICommandCallback calls and / or listeners; this turns out to be useful for various reasons we won't go into here...

Specified by:

execQuietMapCmdList in interface IOptionsServer

Specified by:

execQuietMapCmdList in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inMap - an optional map to be sent to the server as standard input, using the Python map format (-G) form. You must remember to issue the relevant command-specific option to enable this if needed.

Returns:

a non-null Java Map of results; these results are as returned from issuing the command using the -G option with the p4 command line interpreter.

Throws:

P4JavaException - if an error occurs processing this method and its parameters

See Also:

Server.execQuietMapCmdList(java.lang.String, java.lang.String[], java.util.Map)

execInputStringMapCmd

public Map<String,Object>[] execInputStringMapCmd(String cmdName,
                                                  String[] cmdArgs,
                                                  String inString)
                                           throws P4JavaException

Description copied from interface: IServer

Issue an arbitrary P4Java command to the Perforce server and return the results as a map.

This method is intended for low-level commands in the spirit and format of the p4 command line interpreter, and offers a simple way to issue commands to the associated Perforce server without the overhead of the more abstract Java interfaces and methods.

No guidance is given here on the format of the returned map; however, it produces the same output as the p4 command line interpreter in -G (Python map) mode.

Note that this method does not allow you to set "usage" options for the command; these may be added later. Note also that although option arguments passed to this method must be in a form recognized by the p4 command line interpreter, that does not mean the method is being implemented by the interpreter -- the actual implementation depends on the options used to get the server object in the first place from the server factory.

Specified by:

execInputStringMapCmd in interface IServer

Specified by:

execInputStringMapCmd in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inString - an optional string to be sent to the server as standard input unchanged (this must be in the format expected by the server, typically as required when using the "-i" flag to the p4 command line app for the same command). You must remember to issue the relevant command-specific option to enable this if needed.

Returns:

a non-null Java Map of results; these results are as returned from issuing the command using the -G option with the p4 command line interpreter.

Throws:

P4JavaException - if an error occurs processing this method and its parameters

See Also:

Server.execInputStringMapCmd(java.lang.String, java.lang.String[], java.lang.String)

execInputStringMapCmdList

public List<Map<String,Object>> execInputStringMapCmdList(String cmdName,
                                                          String[] cmdArgs,
                                                          String inString)
                                                   throws P4JavaException

Description copied from interface: IOptionsServer

Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps.

This method is intended for low-level commands in the spirit and format of the p4 command line interpreter, and offers a simple way to issue commands to the associated Perforce server without the overhead of the more abstract Java interfaces and methods.

No guidance is given here on the format of the returned map; however, it produces the same output as the p4 command line interpreter in -G (Python map) mode.

Note that this method does not allow you to set "usage" options for the command; these may be added later. Note also that although option arguments passed to this method must be in a form recognized by the p4 command line interpreter, that does not mean the method is being implemented by the interpreter -- the actual implementation depends on the options used to get the server object in the first place from the server factory.

Specified by:

execInputStringMapCmdList in interface IOptionsServer

Specified by:

execInputStringMapCmdList in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inString - an optional string to be sent to the server as standard input unchanged (this must be in the format expected by the server, typically as required when using the "-i" flag to the p4 command line app for the same command). You must remember to issue the relevant command-specific option to enable this if needed.

Returns:

a non-null Java Map of results; these results are as returned from issuing the command using the -G option with the p4 command line interpreter.

Throws:

P4JavaException - if an error occurs processing this method and its parameters

See Also:

Server.execInputStringMapCmdList(java.lang.String, java.lang.String[], java.lang.String)

execInputStringMapCmdList

public List<Map<String,Object>> execInputStringMapCmdList(String cmdName,
                                                          String[] cmdArgs,
                                                          String inString,
                                                          IFilterCallback filterCallback)
                                                   throws P4JavaException

Description copied from interface: IOptionsServer

Issue an arbitrary P4Java command to the Perforce server and return the results as a list of maps.

This method is intended for low-level commands in the spirit and format of the p4 command line interpreter, and offers a simple way to issue commands to the associated Perforce server without the overhead of the more abstract Java interfaces and methods.

No guidance is given here on the format of the returned map; however, it produces the same output as the p4 command line interpreter in -G (Python map) mode.

Note that this method does not allow you to set "usage" options for the command; these may be added later. Note also that although option arguments passed to this method must be in a form recognized by the p4 command line interpreter, that does not mean the method is being implemented by the interpreter -- the actual implementation depends on the options used to get the server object in the first place from the server factory.

Specified by:

execInputStringMapCmdList in interface IOptionsServer

Specified by:

execInputStringMapCmdList in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inString - an optional string to be sent to the server as standard input unchanged (this must be in the format expected by the server, typically as required when using the "-i" flag to the p4 command line app for the same command). You must remember to issue the relevant command-specific option to enable this if needed.

filterCallback - an optional filter callback to decide on skipping or keeping individual key/value pairs as part of the results map.

Returns:

a non-null Java Map of results; these results are as returned from issuing the command using the -G option with the p4 command line interpreter.

Throws:

P4JavaException - if an error occurs processing this method and its parameters

See Also:

Server.execInputStringMapCmdList(java.lang.String, java.lang.String[], java.lang.String, com.perforce.p4java.server.callback.IFilterCallback)

execInputStringStreamingMapComd

@Deprecated
public void execInputStringStreamingMapComd(String cmdName,
                                                       String[] cmdArgs,
                                                       String inString,
                                                       IStreamingCallback callback,
                                                       int key)
                                     throws P4JavaException

Deprecated. As of release 2013.1, replaced by execInputStringStreamingMapCmd(java.lang.String, java.lang.String[], java.lang.String, com.perforce.p4java.server.callback.IStreamingCallback, int)

Description copied from interface: IServer

Issue a streaming map command to the Perforce server, using an optional string for any input expected by the server (such as label or job specs, etc.).

Streaming commands allow users to get each result from a suitably-issued command as it comes in from the server, rather than waiting for the entire command method to complete (and getting the results back as a completed List or Map or whatever).

The results are sent to the user using the IStreamingCallback handleResult method; see the IStreamingCallback Javadoc for details. The payload passed to handleResult is usually the raw map gathered together deep in the RPC protocol layer, and the user is assumed to have the knowledge and technology to be able to parse it and use it suitably in much the same way as a user unpacks or processes the results from the other low-level exec methods like execMapCommand.

NOTE: 'streaming' here has nothing at all to do with Perforce 'streams', which are (or will be) implemented elsewhere.

Specified by:

execInputStringStreamingMapComd in interface IServer

Specified by:

execInputStringStreamingMapComd in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inString - an optional string to be sent to the server as standard input unchanged (this must be in the format expected by the server, typically as required when using the "-i" flag to the p4 command line app for the same command). You must remember to issue the relevant command-specific option to enable this if needed.

callback - a non-null IStreamingCallback to be used to process the incoming results.

key - an opaque integer key that is passed to the IStreamingCallback callback methods to identify the action as being associated with this specific call.

Throws:

P4JavaException - if an error occurs processing this method and its parameters.

See Also:

Server.execInputStringStreamingMapComd(java.lang.String, java.lang.String[], java.lang.String, com.perforce.p4java.server.callback.IStreamingCallback, int)

execInputStringStreamingMapCmd

public void execInputStringStreamingMapCmd(String cmdName,
                                           String[] cmdArgs,
                                           String inString,
                                           IStreamingCallback callback,
                                           int key)
                                    throws P4JavaException

Description copied from interface: IOptionsServer

Issue a streaming map command to the Perforce server, using an optional string for any input expected by the server (such as label or job specs, etc.).

Streaming commands allow users to get each result from a suitably-issued command as it comes in from the server, rather than waiting for the entire command method to complete (and getting the results back as a completed List or Map or whatever).

The results are sent to the user using the IStreamingCallback handleResult method; see the IStreamingCallback Javadoc for details. The payload passed to handleResult is usually the raw map gathered together deep in the RPC protocol layer, and the user is assumed to have the knowledge and technology to be able to parse it and use it suitably in much the same way as a user unpacks or processes the results from the other low-level exec methods like execMapCommand.

NOTE: 'streaming' here has nothing at all to do with Perforce 'streams', which are (or will be) implemented elsewhere.

Specified by:

execInputStringStreamingMapCmd in interface IOptionsServer

Specified by:

execInputStringStreamingMapCmd in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inString - an optional string to be sent to the server as standard input unchanged (this must be in the format expected by the server, typically as required when using the "-i" flag to the p4 command line app for the same command). You must remember to issue the relevant command-specific option to enable this if needed.

callback - a non-null IStreamingCallback to be used to process the incoming results.

key - an opaque integer key that is passed to the IStreamingCallback callback methods to identify the action as being associated with this specific call.

Throws:

P4JavaException - if an error occurs processing this method and its parameters.

See Also:

Server.execInputStringStreamingMapCmd(java.lang.String, java.lang.String[], java.lang.String, com.perforce.p4java.server.callback.IStreamingCallback, int)

execMapCmd

protected Map<String,Object>[] execMapCmd(String cmdName,
                                          String[] cmdArgs,
                                          Map<String,Object> inMap,
                                          String inString,
                                          boolean ignoreCallbacks,
                                          IStreamingCallback callback,
                                          int callbackKey,
                                          IFilterCallback filterCallback)
                                   throws ConnectionException,
                                          AccessException,
                                          RequestException

Throws:

ConnectionException

AccessException

RequestException

execMapCmdList

protected List<Map<String,Object>> execMapCmdList(String cmdName,
                                                  String[] cmdArgs,
                                                  Map<String,Object> inMap,
                                                  String inString,
                                                  boolean ignoreCallbacks,
                                                  IStreamingCallback callback,
                                                  int callbackKey,
                                                  IFilterCallback filterCallback)
                                           throws ConnectionException,
                                                  AccessException,
                                                  RequestException

Throws:

ConnectionException

AccessException

RequestException

execStreamingMapCommand

public void execStreamingMapCommand(String cmdName,
                                    String[] cmdArgs,
                                    Map<String,Object> inMap,
                                    IStreamingCallback callback,
                                    int key)
                             throws P4JavaException

Description copied from interface: IServer

Issue a streaming map command to the Perforce server, using an optional map for any input expected by the server (such as label or job specs, etc.).

Streaming commands allow users to get each result from a suitably-issued command as it comes in from the server, rather than waiting for the entire command method to complete (and getting the results back as a completed List or Map or whatever).

The results are sent to the user using the IStreamingCallback handleResult method; see the IStreamingCallback Javadoc for details. The payload passed to handleResult is usually the raw map gathered together deep in the RPC protocol layer, and the user is assumed to have the knowledge and technology to be able to parse it and use it suitably in much the same way as a user unpacks or processes the results from the other low-level exec methods like execMapCommand.

NOTE: 'streaming' here has nothing at all to do with Perforce 'streams', which are (or will be) implemented elsewhere.

Specified by:

execStreamingMapCommand in interface IServer

Specified by:

execStreamingMapCommand in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inMap - an optional map to be sent to the server as standard input, using the Python map format (-G) form. You must remember to issue the relevant command-specific option to enable this if needed.

callback - a non-null IStreamingCallback to be used to process the incoming results.

key - an opaque integer key that is passed to the IStreamingCallback callback methods to identify the action as being associated with this specific call.

Throws:

P4JavaException - if an error occurs processing this method and its parameters.

See Also:

Server.execStreamingMapCommand(java.lang.String, java.lang.String[], java.util.Map, com.perforce.p4java.server.callback.IStreamingCallback, int)

execQuietStreamCmd

public InputStream execQuietStreamCmd(String cmdName,
                                      String[] cmdArgs)
                               throws ConnectionException,
                                      RequestException,
                                      AccessException

Description copied from interface: IServer

Issue an arbitrary P4Java command to the Perforce server and get the results as a stream without invoking any command callbacks.

Basically equivalent to execStreamCmd with temporary disabling of any ICommandCallback calls and / or listeners; this turns out to be useful for various reasons we won't go into here...

Specified by:

execQuietStreamCmd in interface IServer

Specified by:

execQuietStreamCmd in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

Returns:

an InputStream on the command output. This will never be null, but it may be empty. You must properly close this stream after use or temporary files may be left lying around the VM's java.io.tmpdir area.

Throws:

ConnectionException - if the Perforce server is unreachable or is not connected.

RequestException - if the Perforce server encounters an error during its processing of the request

AccessException - if the Perforce server denies access to the caller

See Also:

Server.execQuietStreamCmd(java.lang.String, java.lang.String[])

execStreamCmd

public InputStream execStreamCmd(String cmdName,
                                 String[] cmdArgs)
                          throws ConnectionException,
                                 RequestException,
                                 AccessException

Description copied from interface: IServer

Issue an arbitrary P4Java command to the Perforce server and get the results as a stream.

This method is intended for low-level commands in the spirit and format of the p4 command line interpreter, and offers a simple way to issue commands to the associated Perforce server without the overhead of the more abstract Java interfaces and methods.

Note that this method is intended for things like getting file contents, and may have unpredictable results on commands not originally expected to return i/o streams.

Note that this method does not allow you to set "usage" options for the command; these may be added later. Note also that although option arguments passed to this method must be in a form recognized by P4Java (as defined by the CmdSpec enum), that does not mean the method is being implemented by the interpreter -- the actual implementation depends on the options used to get the server object in the first place from the server factory.

Specified by:

execStreamCmd in interface IServer

Specified by:

execStreamCmd in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

Returns:

an InputStream on the command output. This will never be null, but it may be empty. You must properly close this stream after use or temporary files may be left lying around the VM's java.io.tmpdir area.

Throws:

ConnectionException - if the Perforce server is unreachable or is not connected.

RequestException - if the Perforce server encounters an error during its processing of the request

AccessException - if the Perforce server denies access to the caller

See Also:

Server.execStreamCmd(java.lang.String, java.lang.String[])

execStreamCmd

public InputStream execStreamCmd(String cmdName,
                                 String[] cmdArgs,
                                 Map<String,Object> inMap)
                          throws P4JavaException

Description copied from interface: IOptionsServer

Issue an arbitrary P4Java command to the Perforce server and get the results as a stream.

This method is intended for low-level commands in the spirit and format of the p4 command line interpreter, and offers a simple way to issue commands to the associated Perforce server without the overhead of the more abstract Java interfaces and methods.

Note that this method is intended for things like getting file contents, and may have unpredictable results on commands not originally expected to return i/o streams.

Note that this method does not allow you to set "usage" options for the command; these may be added later. Note also that although option arguments passed to this method must be in a form recognized by P4Java (as defined by the CmdSpec enum), that does not mean the method is being implemented by the interpreter -- the actual implementation depends on the options used to get the server object in the first place from the server factory.

Specified by:

execStreamCmd in interface IOptionsServer

Specified by:

execStreamCmd in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inMap - an optional map to be sent to the server as standard input, using the Python map format (-G) form. You must remember to issue the relevant command-specific option to enable this if needed.

Returns:

an InputStream on the command output. This will never be null, but it may be empty. You must properly close this stream after use or temporary files may be left lying around the VM's java.io.tmpdir area.

Throws:

ConnectionException - if the Perforce server is unreachable or is not connected.

RequestException - if the Perforce server encounters an error during its processing of the request

AccessException - if the Perforce server denies access to the caller

P4JavaException

See Also:

Server.execStreamCmd(java.lang.String, java.lang.String[], java.util.Map)

execInputStringStreamCmd

public InputStream execInputStringStreamCmd(String cmdName,
                                            String[] cmdArgs,
                                            String inString)
                                     throws P4JavaException

Description copied from interface: IOptionsServer

Issue an arbitrary P4Java command to the Perforce server and return the results as a stream.

This method is intended for low-level commands in the spirit and format of the p4 command line interpreter, and offers a simple way to issue commands to the associated Perforce server without the overhead of the more abstract Java interfaces and methods.

Note that this method is intended for things like getting file contents, and may have unpredictable results on commands not originally expected to return i/o streams.

Note that this method does not allow you to set "usage" options for the command; these may be added later. Note also that although option arguments passed to this method must be in a form recognized by the p4 command line interpreter, that does not mean the method is being implemented by the interpreter -- the actual implementation depends on the options used to get the server object in the first place from the server factory.

Specified by:

execInputStringStreamCmd in interface IOptionsServer

Specified by:

execInputStringStreamCmd in class Server

Parameters:

cmdName - the command to be issued; must be non-null, and correspond to a Perforce command recognized by P4Java and defined in CmdSpec.

cmdArgs - the array of command arguments (options and file arguments, etc.) to be sent to the Perforce server. These must be in the form used by the corresponding p4 command line interpreter. Ignored if null.

inString - an optional string to be sent to the server as standard input unchanged (this must be in the format expected by the server, typically as required when using the "-i" flag to the p4 command line app for the same command). You must remember to issue the relevant command-specific option to enable this if needed.

Returns:

an InputStream on the command output. This will never be null, but it may be empty. You must properly close this stream after use or temporary files may be left lying around the VM's java.io.tmpdir area.

Throws:

P4JavaException - if an error occurs processing this method and its parameters

See Also:

com.perforce.p4java.impl.mapbased.server.Server#execInputStringStreamCmd(java.lang.String, java.lang.String)

execStreamCmd

protected InputStream execStreamCmd(String cmdName,
                                    String[] cmdArgs,
                                    Map<String,Object> inMap,
                                    String inString,
                                    boolean ignoreCallbacks)
                             throws ConnectionException,
                                    RequestException,
                                    AccessException

Note that this method does the access / request exception processing here rather than passing things up the stack; we may introduce an extended version of this method to take the map array as an output parameter in later releases.

Throws:

ConnectionException

RequestException

AccessException

setupCmd

protected ExternalEnv setupCmd(String cmdName,
                               String[] cmdArgs,
                               Map<String,Object> inMap,
                               boolean ignoreCallbacks,
                               int cmdCallBackKey,
                               boolean isStream)
                        throws ConnectionException,
                               AccessException,
                               RequestException

Factors out the command setup that's common to stream and map commands.

Throws:

ConnectionException

AccessException

RequestException

getRpcConnection

public RpcConnection getRpcConnection()

setRpcConnection

public void setRpcConnection(RpcConnection rpcConnection)