Package com.perforce.p4java.impl.mapbased.rpc

Class NtsServerImpl

java.lang.Object
com.perforce.p4java.server.HelixCommandExecutor
com.perforce.p4java.impl.mapbased.server.Server
com.perforce.p4java.impl.mapbased.rpc.RpcServer
com.perforce.p4java.impl.mapbased.rpc.NtsServerImpl
All Implemented Interfaces:
IListDelegator, IServerControl, IAttributeDelegator, IBranchDelegator, IBranchesDelegator, IChangeDelegator, IChangesDelegator, IClientDelegator, IClientsDelegator, ICommitDelegator, IConfigureDelegator, ICounterDelegator, ICountersDelegator, IDBSchemaDelegator, IDepotDelegator, IDepotsDelegator, IDescribeDelegator, IDiff2Delegator, IDirsDelegator, IDiskspaceDelegator, IDuplicateDelegator, IExportDelegator, IExtensionDelegator, IFileAnnotateDelegator, IFileLogDelegator, IFilesDelegator, IFixDelegator, IFixesDelegator, IFstatDelegator, IGraphCommitLogDelegator, IGraphListTreeDelegator, IGraphReceivePackDelegator, IGraphRevListDelegator, IGraphShowRefDelegator, IGrepDelegator, IGroupDelegator, IGroupsDelegator, IInfoDelegator, IIntegratedDelegator, IInterchangesDelegator, IJobDelegator, IJobsDelegator, IJobSpecDelegator, IJournalWaitDelegator, IKeyDelegator, IKeysDelegator, ILabelDelegator, ILabelsDelegator, ILicenseDelegator, ILogin2Delegator, ILoginDelegator, ILogoutDelegator, ILogTailDelegator, IMonitorDelegator, IMoveDelegator, IObliterateDelegator, IOpenedDelegator, IPasswdDelegator, IPrintDelegator, IPropertyDelegator, IProtectDelegator, IProtectsDelegator, IReloadDelegator, IRenameClientDelegator, IRenameUserDelegator, IReposDelegator, IReviewDelegator, IReviewsDelegator, ISearchDelegator, ISizesDelegator, ISpecDelegator, IStatDelegator, IStreamDelegator, IStreamlogDelegator, IStreamsDelegator, ITagDelegator, ITriggersDelegator, IUnloadDelegator, IUserDelegator, IUsersDelegator, IVerifyDelegator, IHelixCommandExecutor, 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 Details

    • SCREEN_NAME

      public static final String SCREEN_NAME
      The short-form name (display name) of this implementation.
      See Also:

    • IMPL_COMMENTS

      public static final String IMPL_COMMENTS
      Implementation-specific comments (dependencies, limitations, etc.).
      See Also:

    • 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:

    • DEFAULT_STATUS

      public static final boolean DEFAULT_STATUS
      True IFF this is the default implementation. There must be only one of these...
      See Also:

    • TRACE_PREFIX

      public static final String TRACE_PREFIX
      What we use as a P4JTracer trace prefix for methods here.
      See Also:

    • protocolSpecs

      protected ProtocolCommand protocolSpecs

    • dispatcher

      protected RpcPacketDispatcher dispatcher

    • rpcConnection

      protected RpcConnection rpcConnection

    • globalOptions

      protected List<String> globalOptions
      Global Options for this server

  • Constructor Details

    • NtsServerImpl

      public NtsServerImpl()

  • Method Details

    • 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.
      Specified by:
      init in interface IServerControl
      Overrides:
      init in class Server
      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:

    • init

      public ServerStatus init(String host, int port, Properties properties, 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
      properties - 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 - secure option
      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:

    • 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:

    • 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
      props - 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:

    • 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:

    • 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 - on error
      AccessException - on error
      See Also:

    • 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:

    • 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.

      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:

    • execMapCmdList

      public List<Map<String,Object>> execMapCmdList(String cmdName, String[] cmdArgs, Map<String,Object> inMap) throws ConnectionException, AccessException, RequestException
      Description copied from interface: IHelixCommandExecutor
      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.

      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:
      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:

    • execMapCmdList

      public List<Map<String,Object>> execMapCmdList(String cmdName, String[] cmdArgs, Map<String,Object> inMap, IFilterCallback filterCallback) throws P4JavaException
      Description copied from interface: IHelixCommandExecutor
      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.

      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:

    • 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...

      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:

    • 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...

      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:

    • 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.

      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:

    • 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.

      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:

    • 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.

      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:

    • execMapCmdList

      public List<Map<String,Object>> execMapCmdList(String cmdName, String[] cmdArgs, IFilterCallback filterCallback, IParallelCallback parallelCallback) 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.

      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.
      filterCallback - an optional filter callback to decide on skipping or keeping individual key/value pairs as part of the results map.
      parallelCallback - an optional parallel sync/submit callback to provide a multi-threaded file transfer implementation.
      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

    • 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.

      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:

    • 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.

      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:

    • 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, IParallelCallback parallelCallback) throws ConnectionException, AccessException, RequestException
      Throws:
      ConnectionException
      AccessException
      RequestException

    • setGlobalOptions

      public void setGlobalOptions(List<String> s)
      Description copied from interface: IOptionsServer
      Set Global Option for perforce commands
      Parameters:
      s - given global options as a list

    • getGlobalOptions

      public List<String> getGlobalOptions()
      Description copied from interface: IOptionsServer
      Returns the list of all Global Option for a server
      Returns:
      non-null list of global options

    • 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.

      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:

    • execStreamingMapCommand

      public void execStreamingMapCommand(String cmdName, String[] cmdArgs, Map<String,Object> inMap, IStreamingCallback callback, int key, IParallelCallback parallelCallback) throws P4JavaException
      Description copied from interface: IServer
      Issue a parallelised 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.

      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.
      parallelCallback - IParallelCallback used to parallelise the task
      Throws:
      P4JavaException - on error

    • 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...

      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:

    • execStreamCmd

      public InputStream execStreamCmd(String cmdName, String[] cmdArgs) throws ConnectionException, RequestException, AccessException
      Description copied from interface: IHelixCommandExecutor
      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.

      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:

    • execStreamCmdForBuffer

      public ByteBuffer execStreamCmdForBuffer(String cmdName, String[] cmdArgs) throws ConnectionException, RequestException, AccessException
      Description copied from interface: IHelixCommandExecutor
      Issue an arbitrary P4Java command to the Perforce server and get the results as a byte buffer.
      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 ByteBuffer on the command output. This will never be null, but it may be empty.
      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

    • 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.

      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:

    • 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.

      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:

    • 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.
      Parameters:
      cmdName - cmdName
      cmdArgs - cmdArgs
      inMap - inMap
      inString - inString
      ignoreCallbacks - ignoreCallbacks
      Returns:
      stream
      Throws:
      ConnectionException - on error
      RequestException - on error
      AccessException - on error

    • execStreamCmdForBuffer

      protected ByteBuffer execStreamCmdForBuffer(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.
      Parameters:
      cmdName - cmdName
      cmdArgs - cmdArgs
      inMap - inMap
      inString - inString
      ignoreCallbacks - ignoreCallbacks
      Returns:
      byte buffer
      Throws:
      ConnectionException - on error
      RequestException - on error
      AccessException - on error

    • 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.
      Parameters:
      cmdName - cmdName
      cmdArgs - cmdArgs
      inMap - inMap
      ignoreCallbacks - ignoreCallbacks
      cmdCallBackKey - cmdCallBackKey
      isStream - isStream
      Returns:
      ExternalEnv
      Throws:
      ConnectionException - on error
      AccessException - on error
      RequestException - on error

    • getRpcConnection

      public RpcConnection getRpcConnection()

    • setRpcConnection

      public void setRpcConnection(RpcConnection rpcConnection)

    • getServerAddressDetails

      public IServerAddress getServerAddressDetails()
      Get server address object
      Specified by:
      getServerAddressDetails in class Server
      Returns:
      server address object