* 'concurrency' : How many file operations can be done in parallel.
*
* @param $config Array
+ * @throws MWException
*/
public function __construct( array $config ) {
$this->name = $config['name'];
* @return Status
*/
final public function create( array $params, array $opts = array() ) {
- $params['op'] = 'create';
- return $this->doOperation( $params, $opts );
+ return $this->doOperation( array( 'op' => 'create' ) + $params, $opts );
}
/**
* @return Status
*/
final public function store( array $params, array $opts = array() ) {
- $params['op'] = 'store';
- return $this->doOperation( $params, $opts );
+ return $this->doOperation( array( 'op' => 'store' ) + $params, $opts );
}
/**
* @return Status
*/
final public function copy( array $params, array $opts = array() ) {
- $params['op'] = 'copy';
- return $this->doOperation( $params, $opts );
+ return $this->doOperation( array( 'op' => 'copy' ) + $params, $opts );
}
/**
* @return Status
*/
final public function move( array $params, array $opts = array() ) {
- $params['op'] = 'move';
- return $this->doOperation( $params, $opts );
+ return $this->doOperation( array( 'op' => 'move' ) + $params, $opts );
}
/**
* @return Status
*/
final public function delete( array $params, array $opts = array() ) {
- $params['op'] = 'delete';
- return $this->doOperation( $params, $opts );
+ return $this->doOperation( array( 'op' => 'delete' ) + $params, $opts );
+ }
+
+ /**
+ * Perform a set of independent file operations on some files.
+ *
+ * This does no locking, nor journaling, and possibly no stat calls.
+ * Any destination files that already exist will be overwritten.
+ * This should *only* be used on non-original files, like cache files.
+ *
+ * Supported operations and their parameters:
+ * a) Create a new file in storage with the contents of a string
+ * array(
+ * 'op' => 'create',
+ * 'dst' => <storage path>,
+ * 'content' => <string of new file contents>
+ * )
+ * b) Copy a file system file into storage
+ * array(
+ * 'op' => 'store',
+ * 'src' => <file system path>,
+ * 'dst' => <storage path>
+ * )
+ * c) Copy a file within storage
+ * array(
+ * 'op' => 'copy',
+ * 'src' => <storage path>,
+ * 'dst' => <storage path>
+ * )
+ * d) Move a file within storage
+ * array(
+ * 'op' => 'move',
+ * 'src' => <storage path>,
+ * 'dst' => <storage path>
+ * )
+ * e) Delete a file within storage
+ * array(
+ * 'op' => 'delete',
+ * 'src' => <storage path>,
+ * 'ignoreMissingSource' => <boolean>
+ * )
+ * f) Do nothing (no-op)
+ * array(
+ * 'op' => 'null',
+ * )
+ *
+ * Boolean flags for operations (operation-specific):
+ * 'ignoreMissingSource' : The operation will simply succeed and do
+ * nothing if the source file does not exist.
+ *
+ * Return value:
+ * This returns a Status, which contains all warnings and fatals that occured
+ * during the operation. The 'failCount', 'successCount', and 'success' members
+ * will reflect each operation attempted for the given files. The status will be
+ * considered "OK" as long as no fatal errors occured.
+ *
+ * @param $ops Array Set of operations to execute
+ * @return Status
+ * @since 1.20
+ */
+ final public function doQuickOperations( array $ops ) {
+ if ( $this->isReadOnly() ) {
+ return Status::newFatal( 'backend-fail-readonly', $this->name, $this->readOnly );
+ }
+ foreach ( $ops as &$op ) {
+ $op['overwrite'] = true; // avoids RTTs in key/value stores
+ }
+ return $this->doQuickOperationsInternal( $ops );
+ }
+
+ /**
+ * @see FileBackend::doQuickOperations()
+ * @since 1.20
+ */
+ abstract protected function doQuickOperationsInternal( array $ops );
+
+ /**
+ * Same as doQuickOperations() except it takes a single operation.
+ * If you are doing a batch of operations, then use that function instead.
+ *
+ * @see FileBackend::doQuickOperations()
+ *
+ * @param $op Array Operation
+ * @return Status
+ * @since 1.20
+ */
+ final public function doQuickOperation( array $op ) {
+ return $this->doQuickOperations( array( $op ) );
+ }
+
+ /**
+ * Performs a single quick create operation.
+ * This sets $params['op'] to 'create' and passes it to doQuickOperation().
+ *
+ * @see FileBackend::doQuickOperation()
+ *
+ * @param $params Array Operation parameters
+ * @return Status
+ * @since 1.20
+ */
+ final public function quickCreate( array $params ) {
+ return $this->doQuickOperation( array( 'op' => 'create' ) + $params );
+ }
+
+ /**
+ * Performs a single quick store operation.
+ * This sets $params['op'] to 'store' and passes it to doQuickOperation().
+ *
+ * @see FileBackend::doQuickOperation()
+ *
+ * @param $params Array Operation parameters
+ * @return Status
+ * @since 1.20
+ */
+ final public function quickStore( array $params ) {
+ return $this->doQuickOperation( array( 'op' => 'store' ) + $params );
+ }
+
+ /**
+ * Performs a single quick copy operation.
+ * This sets $params['op'] to 'copy' and passes it to doQuickOperation().
+ *
+ * @see FileBackend::doQuickOperation()
+ *
+ * @param $params Array Operation parameters
+ * @return Status
+ * @since 1.20
+ */
+ final public function quickCopy( array $params ) {
+ return $this->doQuickOperation( array( 'op' => 'copy' ) + $params );
+ }
+
+ /**
+ * Performs a single quick move operation.
+ * This sets $params['op'] to 'move' and passes it to doQuickOperation().
+ *
+ * @see FileBackend::doQuickOperation()
+ *
+ * @param $params Array Operation parameters
+ * @return Status
+ * @since 1.20
+ */
+ final public function quickMove( array $params ) {
+ return $this->doQuickOperation( array( 'op' => 'move' ) + $params );
+ }
+
+ /**
+ * Performs a single quick delete operation.
+ * This sets $params['op'] to 'delete' and passes it to doQuickOperation().
+ *
+ * @see FileBackend::doQuickOperation()
+ *
+ * @param $params Array Operation parameters
+ * @return Status
+ * @since 1.20
+ */
+ final public function quickDelete( array $params ) {
+ return $this->doQuickOperation( array( 'op' => 'delete' ) + $params );
}
/**
* $params include:
* dir : storage directory
*
+ * @param $params array
* @return bool|null Returns null on failure
* @since 1.20
*/
* dir : storage directory
* topOnly : only return direct child dirs of the directory
*
+ * @param $params array
* @return Traversable|Array|null Returns null on failure
* @since 1.20
*/
* $params include:
* dir : storage directory
*
+ * @param $params array
* @return Traversable|Array|null Returns null on failure
* @since 1.20
*/
* dir : storage directory
* topOnly : only return direct child files of the directory (@since 1.20)
*
+ * @param $params array
* @return Traversable|Array|null Returns null on failure
*/
abstract public function getFileList( array $params );
* $params include:
* dir : storage directory
*
+ * @param $params array
* @return Traversable|Array|null Returns null on failure
* @since 1.20
*/
return ScopedLock::factory( $this->lockManager, $paths, $type, $status );
}
+ /**
+ * Get an array of scoped locks needed for a batch of file operations.
+ *
+ * Normally, FileBackend::doOperations() handles locking, unless
+ * the 'nonLocking' param is passed in. This function is useful if you
+ * want the files to be locked for a broader scope than just when the
+ * files are changing. For example, if you need to update DB metadata,
+ * you may want to keep the files locked until finished.
+ *
+ * @see FileBackend::doOperations()
+ *
+ * @param $ops Array List of file operations to FileBackend::doOperations()
+ * @param $status Status Status to update on lock/unlock
+ * @return Array List of ScopedFileLocks or null values
+ * @since 1.20
+ */
+ abstract public function getScopedLocksForOps( array $ops, Status $status );
+
/**
* Get the root storage path of this backend.
* All container paths are "subdirectories" of this path.
return "mwstore://{$this->name}";
}
+ /**
+ * Get the file journal object for this backend
+ *
+ * @return FileJournal
+ */
+ final public function getJournal() {
+ return $this->fileJournal;
+ }
+
/**
* Check if a given path is a "mwstore://" path.
* This does not do any further validation or any existence checks.