com.perforce.p4java.impl.mapbased.rpc.func.client
Class ClientSystemFileCommands

java.lang.Object
  com.perforce.p4java.impl.mapbased.rpc.func.client.ClientSystemFileCommands

public class ClientSystemFileCommands
extends Object

Implements the simpler lower-level file commands that typically correspond to system commands such as chmod, delete, etc.

TRACE_PREFIX

public static final String TRACE_PREFIX

See Also:

Constant Field Values

DEFAULT_TMPFILE_PFX

public static final String DEFAULT_TMPFILE_PFX

See Also:

Constant Field Values

DEFAULT_TMPFILE_SFX

public static final String DEFAULT_TMPFILE_SFX

See Also:

Constant Field Values

SYSTEM_TMPDIR_PROPS_KEY

public static final String SYSTEM_TMPDIR_PROPS_KEY

See Also:

Constant Field Values

SYSTEM_TMPDIR_DEFAULT

public static final String SYSTEM_TMPDIR_DEFAULT

See Also:

Constant Field Values

PERMS_RW

public static final String PERMS_RW

See Also:

Constant Field Values

FILE_DELETE_ON_ERR_KEY

protected static final String FILE_DELETE_ON_ERR_KEY

See Also:

Constant Field Values

FILE_OPEN_PATH_KEY

protected static final String FILE_OPEN_PATH_KEY

See Also:

Constant Field Values

FILE_OPEN_TARGET_FILE_KEY

protected static final String FILE_OPEN_TARGET_FILE_KEY

See Also:

Constant Field Values

FILE_OPEN_TMP_FILE_KEY

protected static final String FILE_OPEN_TMP_FILE_KEY

See Also:

Constant Field Values

FILE_OPEN_TMP_STREAM_KEY

protected static final String FILE_OPEN_TMP_STREAM_KEY

See Also:

Constant Field Values

FILE_OPEN_TARGET_STREAM_KEY

protected static final String FILE_OPEN_TARGET_STREAM_KEY

See Also:

Constant Field Values

FILE_OPEN_ORIG_ARGS_KEY

protected static final String FILE_OPEN_ORIG_ARGS_KEY

See Also:

Constant Field Values

FILE_OPEN_MODTIME_KEY

protected static final String FILE_OPEN_MODTIME_KEY

See Also:

Constant Field Values

FILE_OPEN_IS_SYMBOLIC_LINK_KEY

protected static final String FILE_OPEN_IS_SYMBOLIC_LINK_KEY

See Also:

Constant Field Values

RECONCILE_HANDLER_SKIP_ADD_KEY

protected static final String RECONCILE_HANDLER_SKIP_ADD_KEY

See Also:

Constant Field Values

ClientSystemFileCommands

protected ClientSystemFileCommands(Properties props,
                                   RpcServer server)

chmodFile

protected RpcPacketDispatcher.RpcPacketDispatcherResult chmodFile(RpcConnection rpcConnection,
                                                                  CommandEnv cmdEnv,
                                                                  Map<String,Object> resultsMap)
                                                           throws ConnectionException

Change the r/w (etc.) mode of a file locally.

Throws:

ConnectionException

openFile

protected RpcPacketDispatcher.RpcPacketDispatcherResult openFile(RpcConnection rpcConnection,
                                                                 CommandEnv cmdEnv,
                                                                 Map<String,Object> resultsMap)
                                                          throws ConnectionException

Open a client file for writing. We have to process things like NOCLOBBER, and ensure we write to a temp file if a file already exists, etc. Much of the logic here is straight from the C++ API, currently minus the OpenDiff functionality (which will probably be factored out elsewhere).

We also have to leave the associated file descriptor (or channel equivalent) lying around for the rest of the function sequence to be able to pick up.

Note that we also now implement the 10.2 sync (etc.) transfer integrity checks; this is actually fairly easy as it can be done on the raw (un-translated) data coming in to the write methods (as opposed to checkFile's version, which has to consider the translated data). We do most of this work in the RpcOutputStream and RpcPerforceFile classes after setting things up here; closeFile does the final round up and delivers the verdict. This all only happens if Server.nonCheckedSyncs is false.

The temp file created here will be deleted in the subsequent closeFile() method call.

Throws:

ConnectionException

writeFile

protected RpcPacketDispatcher.RpcPacketDispatcherResult writeFile(RpcConnection rpcConnection,
                                                                  CommandEnv cmdEnv,
                                                                  Map<String,Object> resultsMap)
                                                           throws ConnectionException

Write file contents to the target file. This method assumes that fileOpen has previously been called, and that the state map contains at least one valid file output stream to write bytes to.

Throws:

ConnectionException

writeText

protected RpcPacketDispatcher.RpcPacketDispatcherResult writeText(RpcConnection rpcConnection,
                                                                  CommandEnv cmdEnv,
                                                                  Map<String,Object> resultsMap)
                                                           throws ConnectionException

Handles the client-OutputText command.

Basically uses writeBinary (below) with the twist that we currently throw an exception when we see the trans option (which we haven't implemented yet).

Note that -- like the C++ API -- no line end munging is performed -- we just throw what's coming at us straight back to whoever's catching it...

Throws:

ConnectionException

writeBinary

protected RpcPacketDispatcher.RpcPacketDispatcherResult writeBinary(RpcConnection rpcConnection,
                                                                    CommandEnv cmdEnv,
                                                                    Map<String,Object> resultsMap)
                                                             throws ConnectionException

A specialised method to handle the client-OutputBinary command.

Note that this method fakes a handler to keep state around, and assumes that the target (tmp) stream has been passed-in by the higher levels in the cmdEnv state map.

Throws:

ConnectionException

closeFile

protected RpcPacketDispatcher.RpcPacketDispatcherResult closeFile(RpcConnection rpcConnection,
                                                                  CommandEnv cmdEnv,
                                                                  Map<String,Object> resultsMap)
                                                           throws ConnectionException

Close a file that was opened earlier for writing. Depending on circumstances, this may involve moving a temporary file and / or deleting other files, etc., and stitching up permissions, etc. (we are often not allowed to change a file's executable bits in places like /tmp, etc., so we do it here...).

Throws:

ConnectionException

moveFile

protected RpcPacketDispatcher.RpcPacketDispatcherResult moveFile(RpcConnection rpcConnection,
                                                                 CommandEnv cmdEnv,
                                                                 Map<String,Object> resultsMap)
                                                          throws ConnectionException

Move a file from one location to another. Supports the new 2009.1 smart move command.

Throws:

ConnectionException

deleteFile

protected RpcPacketDispatcher.RpcPacketDispatcherResult deleteFile(RpcConnection rpcConnection,
                                                                   CommandEnv cmdEnv,
                                                                   Map<String,Object> resultsMap)
                                                            throws ConnectionException

Throws:

ConnectionException

checkFile

protected RpcPacketDispatcher.RpcPacketDispatcherResult checkFile(RpcConnection rpcConnection,
                                                                  CommandEnv cmdEnv,
                                                                  Map<String,Object> resultsMap)
                                                           throws ConnectionException

The infamous checkFile omnibus method, used to, well, check files on the Perforce client side. Basically copied and transliterated into Java from the C++ original; not all of it currently makes sense in a Java environment, but this will be fixed (HR).

Much of the work happens off-stage in the support methods elsewhere. What follows is copied from the C++ API:

This routine, for compatibility purposes, has several modes.

1. If clientType is set, we know the type and we're checking to see if the file exists and (if digest is set) if the file has the same fingerprint. We return this in "status" with a value of "missing", "exists", or "same". This starts around version 1742.

2. If clientType is unset, we're looking for the type of the file, and we'll return it in "type". This is sort of overloaded, 'cause it can also get set with pseudo-types like "missing". In this case, we use the "xfiles" protocol check to make sure we don't return something the server doesn't expect.

        - xfiles unset: return text, binary.
        - xfiles >= 0: also return xtext, xbinary.
        - xfiles >= 1: also return symlink.
        - xfiles >= 2; also return resource (mac resource file).  
        - xfiles >= 3; also return ubinary
        - xfiles >= 4; also return apple
 

If forceType is set, we'll use that in preference over what we've discovered. We still check the file (to make sure they're not adding a directory, and so they get to right warning if they add an empty file), but we'll just override that back to the (typemap's) forceType.

We map empty/missing/unreadable into forceType/"text".

Throws:

ConnectionException

reconcileEdit

protected RpcPacketDispatcher.RpcPacketDispatcherResult reconcileEdit(RpcConnection rpcConnection,
                                                                      CommandEnv cmdEnv,
                                                                      Map<String,Object> resultsMap)
                                                               throws ConnectionException

"inquire" about file, for 'p4 reconcile'

This routine performs clientCheckFile's scenario 1 checking, but also saves the list of files that are in the depot so they can be compared to the list of files on the client when reconciling later for add.

Throws:

ConnectionException

reconcileAdd

protected RpcPacketDispatcher.RpcPacketDispatcherResult reconcileAdd(RpcConnection rpcConnection,
                                                                     CommandEnv cmdEnv,
                                                                     Map<String,Object> resultsMap)
                                                              throws ConnectionException

Reconcile add confirm - scans the directory (local syntax) and returns files in the directory using the full path. This supports traversing sub-directories.

TODO: Check MapApi; if no mapping, continue; Currently, just rely on server side MapApi validation.

Throws:

ConnectionException

reconcileFlush

protected RpcPacketDispatcher.RpcPacketDispatcherResult reconcileFlush(RpcConnection rpcConnection,
                                                                       CommandEnv cmdEnv,
                                                                       Map<String,Object> resultsMap)
                                                                throws ConnectionException

Reconcile flush - remove the skip add files map from the reconcile handler.

Throws:

ConnectionException

getTempOutputStream

public RpcOutputStream getTempOutputStream(CommandEnv cmdEnv)
                                    throws ConnectionException

Return the temp RPC output stream. If it doesn't exist, try to create a new one only if the command is run from a "streamCmd" method or tracking is enabled.

Throws:

ConnectionException

convertFileDataMap

public Map<String,Object> convertFileDataMap(Map<String,Object> map,
                                             Charset charset,
                                             boolean isUnicodeServer)

getFiles

public static void getFiles(File dir,
                            FilenameFilter filter,
                            List<File> files)

Recursively get all files in a directory.

Note: must pass in a non-null 'files' list as a parameter.