| Current File : /home/escuelai/public_html/wp-content/plugins/w3-total-cache/CdnEngine_GoogleDrive.php |
<?php
/**
* File: CdnEngine_GoogleDrive.php
*
* @package W3TC
*/
namespace W3TC;
/**
* Class CdnEngine_GoogleDrive
*
* Google drive engine
*
* phpcs:disable PSR2.Classes.PropertyDeclaration.Underscore
* phpcs:disable PSR2.Methods.MethodDeclaration.Underscore
* phpcs:disable WordPress.PHP.NoSilencedErrors.Discouraged
* phpcs:disable WordPress.PHP.DiscouragedPHPFunctions
* phpcs:disable WordPress.WP.AlternativeFunctions
* phpcs:disable WordPress.DB.DirectDatabaseQuery
* phpcs:disable WordPress.DB.PreparedSQL.NotPrepared
*/
class CdnEngine_GoogleDrive extends CdnEngine_Base {
/**
* Client ID
*
* @var string
*/
private $_client_id;
/**
* Refresh token
*
* @var string
*/
private $_refresh_token;
/**
* Root folder ID
*
* @var string
*/
private $_root_folder_id;
/**
* Root URL
*
* @var string
*/
private $_root_url;
/**
* Google Service Drive object
*
* @var W3TCG_Google_Service_Drive
*/
private $_service;
/**
* Tablename pathmap
*
* @var string
*/
private $_tablename_pathmap;
/**
* Callback function to handle the updated access token.
*
* This callback is invoked with the new access token whenever the token is refreshed.
*
* @var callable
*/
private $_new_access_token_callback;
/**
* Constructor to initialize the Google Drive CDN engine.
*
* @param array $config {
* Configuration options for the Google Drive CDN engine.
*
* @type string $client_id The client ID for the Google Drive API.
* @type string $refresh_token The refresh token for authentication.
* @type string $root_folder_id The root folder ID for the Google Drive.
* @type string $root_url The root URL for the Google Drive CDN.
* @type callable $new_access_token_callback Callback function for new access token.
* @type string $access_token The access token for authentication.
* }
*/
public function __construct( $config = array() ) {
parent::__construct( $config );
$this->_client_id = $config['client_id'];
$this->_refresh_token = $config['refresh_token'];
$this->_root_folder_id = $config['root_folder_id'];
$this->_root_url = rtrim( $config['root_url'], '/' ) . '/';
$this->_new_access_token_callback = $config['new_access_token_callback'];
global $wpdb;
$this->_tablename_pathmap = $wpdb->base_prefix . W3TC_CDN_TABLE_PATHMAP;
try {
$this->_init_service( $config['access_token'] );
} catch ( \Exception $e ) {
$this->_service = null;
}
}
/**
* Initializes the Google Drive service with the provided access token.
*
* @param string $access_token The access token used to authenticate with the Google Drive API.
*
* @throws \Exception If the client ID or access token is missing, or if the service initialization fails.
*/
private function _init_service( $access_token ) {
if ( empty( $this->_client_id ) || empty( $access_token ) ) {
throw new \Exception( \esc_html__( 'Service not configured.', 'w3-total-cache' ) );
}
$client = new \W3TCG_Google_Client();
$client->setClientId( $this->_client_id );
$client->setAccessToken( $access_token );
$this->_service = new \W3TCG_Google_Service_Drive( $client );
}
/**
* Refreshes the access token using the stored refresh token.
*
* @throws \Exception If the refresh request fails or returns an error.
*/
private function _refresh_token() {
$result = wp_remote_post(
W3TC_GOOGLE_DRIVE_AUTHORIZE_URL,
array(
'body' => array(
'client_id' => $this->_client_id,
'refresh_token' => $this->_refresh_token,
),
)
);
if ( is_wp_error( $result ) ) {
throw new \Exception( esc_html( $result ) );
} elseif ( 200 !== (int) $result['response']['code'] ) {
throw new \Exception( wp_kses_post( $result['body'] ) );
}
$access_token = $result['body'];
call_user_func( $this->_new_access_token_callback, $access_token );
$this->_init_service( $access_token );
}
/**
* Uploads files to Google Drive.
*
* @param array $files Array of file descriptors to upload. Each descriptor must contain the 'local_path' and 'remote_path' at a minimum.
* @param array $results Reference to an array where the upload results will be stored.
* @param bool $force_rewrite Whether to forcefully overwrite existing files on Google Drive (default: false).
* @param int $timeout_time Optional timeout time in seconds for the upload operation.
*
* @return bool|string True if the upload was successful, or 'timeout' if the upload timed out.
*/
public function upload( $files, &$results, $force_rewrite = false, $timeout_time = null ) {
if ( is_null( $this->_service ) ) {
return false;
}
$allow_refresh_token = true;
$result = true;
$files_chunks = array_chunk( $files, 20 );
foreach ( $files_chunks as $files_chunk ) {
$r = $this->_upload_chunk(
$files_chunk,
$results,
$force_rewrite,
$timeout_time,
$allow_refresh_token
);
if ( 'refresh_required' === $r ) {
$allow_refresh_token = false;
$this->_refresh_token();
$r = $this->_upload_chunk(
$files_chunk,
$results,
$force_rewrite,
$timeout_time,
$allow_refresh_token
);
}
if ( 'success' !== $r ) {
$result = false;
}
if ( 'timeout' === $r ) {
return 'timeout';
}
}
return $result;
}
/**
* Converts file properties to a Google Drive path.
*
* @param object $file The file object containing properties to convert.
*
* @return string|null The constructed path or null if no valid path properties are found.
*/
private function _properties_to_path( $file ) {
$path_pieces = array();
foreach ( $file->properties as $p ) {
$k = ( 'path' === $p->key ) ? 'path1' : $p->key;
if ( ! preg_match( '/^path[0-9]+$/', $k ) ) {
continue;
}
$path_pieces[ $k ] = $p->value;
}
if ( 0 === count( $path_pieces ) ) {
return null;
}
ksort( $path_pieces );
return join( $path_pieces );
}
/**
* Converts a path string into an array of Google Drive properties.
*
* From google drive api docs:
* Maximum of 124 bytes size per property (including both key and value) string in UTF-8 encoding.
* Maximum of 30 private properties per file from any one application.
*
* @param string $path The path to convert into Google Drive properties.
*
* @return array An array of Google Drive property objects representing the path.
*/
private function _path_to_properties( $path ) {
$chunks = str_split( $path, 55 );
$properties = array();
$i = 1;
foreach ( $chunks as $chunk ) {
$p = new \W3TCG_Google_Service_Drive_Property();
$p->key = 'path' . $i;
$p->value = $chunk;
$properties[] = $p;
++$i;
}
return $properties;
}
/**
* Uploads a chunk of files to Google Drive.
*
* @param array $files Array of file descriptors to upload in the current chunk.
* @param array $results Reference to an array where the upload results will be stored.
* @param bool $force_rewrite Whether to forcefully overwrite existing files on Google Drive.
* @param int $timeout_time Optional timeout time in seconds for the upload operation.
* @param bool $allow_refresh_token Whether to allow refreshing the access token if necessary.
*
* @return string One of the following: 'success', 'timeout', 'refresh_required', or 'with_errors'.
*
* @throws \W3TCG_Google_Auth_Exception If the file update/insert fails.
*/
private function _upload_chunk( $files, &$results, $force_rewrite, $timeout_time, $allow_refresh_token ) {
list( $result, $listed_files ) = $this->list_files_chunk( $files, $allow_refresh_token, $timeout_time );
if ( 'success' !== $result ) {
return $result;
}
$files_by_path = array();
foreach ( $listed_files as $existing_file ) {
$path = $this->_properties_to_path( $existing_file );
if ( $path ) {
$files_by_path[ $path ] = $existing_file;
}
}
// check update date and upload.
foreach ( $files as $file_descriptor ) {
$remote_path = $file_descriptor['remote_path'];
// process at least one item before timeout so that progress goes on.
if ( ! empty( $results ) ) {
if ( ! is_null( $timeout_time ) && time() > $timeout_time ) {
return 'timeout';
}
}
list( $parent_id, $title ) = $this->remote_path_to_title( $file_descriptor['remote_path'] );
$properties = $this->_path_to_properties( $remote_path );
if ( isset( $file_descriptor['content'] ) ) {
// when content specified - just upload.
$content = $file_descriptor['content'];
} else {
$local_path = $file_descriptor['local_path'];
if ( ! file_exists( $local_path ) ) {
$results[] = $this->_get_result(
$local_path,
$remote_path,
W3TC_CDN_RESULT_ERROR,
'Source file not found.',
$file_descriptor
);
continue;
}
$mtime = @filemtime( $local_path );
$p = new \W3TCG_Google_Service_Drive_Property();
$p->key = 'mtime';
$p->value = $mtime;
$properties[] = $p;
if ( ! $force_rewrite && isset( $files_by_path[ $remote_path ] ) ) {
$existing_file = $files_by_path[ $remote_path ];
$existing_size = $existing_file->fileSize; // phpcs:ignore WordPress.NamingConventions.ValidVariableName.UsedPropertyNotSnakeCase
$existing_mtime = 0;
if ( is_array( $existing_file->properties ) ) {
foreach ( $existing_file->properties as $p ) {
if ( 'mtime' === $p->key ) {
$existing_mtime = $p->value;
}
}
}
$size = @filesize( $local_path );
if ( $mtime === $existing_mtime && $size === $existing_size ) {
$results[] = $this->_get_result(
$file_descriptor['local_path'],
$remote_path,
W3TC_CDN_RESULT_OK,
'File up-to-date.',
$file_descriptor
);
continue;
}
}
$content = file_get_contents( $local_path );
}
$file = new \W3TCG_Google_Service_Drive_DriveFile();
$file->setTitle( $title );
$file->setProperties( $properties );
$parent = new \W3TCG_Google_Service_Drive_ParentReference();
$parent->setId( $parent_id );
$file->setParents( array( $parent ) );
try {
try {
// update file if there's one already or insert.
if ( isset( $files_by_path[ $remote_path ] ) ) {
$existing_file = $files_by_path[ $remote_path ];
$created_file = $this->_service->files->update(
$existing_file->id,
$file,
array(
'data' => $content,
'uploadType' => 'media',
)
);
} else {
$created_file = $this->_service->files->insert(
$file,
array(
'data' => $content,
'uploadType' => 'media',
)
);
$permission = new \W3TCG_Google_Service_Drive_Permission();
$permission->setValue( '' );
$permission->setType( 'anyone' );
$permission->setRole( 'reader' );
$this->_service->permissions->insert( $created_file->id, $permission );
}
} catch ( \W3TCG_Google_Auth_Exception $e ) {
if ( $allow_refresh_token ) {
return 'refresh_required';
}
throw $e;
}
$results[] = $this->_get_result(
$file_descriptor['local_path'],
$remote_path,
W3TC_CDN_RESULT_OK,
'OK',
$file_descriptor
);
$this->path_set_id( $remote_path, $created_file->id );
} catch ( \W3TCG_Google_Service_Exception $e ) {
$errors = $e->getErrors();
$details = '';
if ( count( $errors ) >= 1 ) {
$details = wp_json_encode( $errors );
}
delete_transient( 'w3tc_cdn_google_drive_folder_ids' );
$results[] = $this->_get_result(
$file_descriptor['local_path'],
$remote_path,
W3TC_CDN_RESULT_ERROR,
'Failed to upload file ' . $remote_path . ' ' . $details,
$file_descriptor
);
$result = 'with_errors';
continue;
} catch ( \Exception $e ) {
delete_transient( 'w3tc_cdn_google_drive_folder_ids' );
$results[] = $this->_get_result(
$file_descriptor['local_path'],
$remote_path,
W3TC_CDN_RESULT_ERROR,
'Failed to upload file ' . $remote_path,
$file_descriptor
);
$result = 'with_errors';
continue;
}
}
return $result;
}
/**
* Deletes specified files from the Google Drive.
*
* This method processes the deletion of multiple files from Google Drive in chunks. It handles token refresh
* if necessary and updates the result of the deletion process.
*
* @param array $files The list of file paths to be deleted.
* @param array $results The array to collect results of each file deletion.
*
* @return bool True on success, false on failure.
*/
public function delete( $files, &$results ) {
$allow_refresh_token = true;
$result = true;
$files_chunks = array_chunk( $files, 20 );
foreach ( $files_chunks as $files_chunk ) {
$r = $this->_delete_chunk( $files_chunk, $results, $allow_refresh_token );
if ( 'refresh_required' === $r ) {
$allow_refresh_token = false;
$this->_refresh_token();
$r = $this->_delete_chunk( $files_chunk, $results, $allow_refresh_token );
}
if ( 'success' !== $r ) {
$result = false;
}
}
return $result;
}
/**
* Deletes a chunk of files from Google Drive.
*
* This method handles the deletion of a chunk of files, processes the API response, and updates the results array.
*
* @param array $files The chunk of file paths to delete.
* @param array $results The array to collect results of each file deletion.
* @param bool $allow_refresh_token Flag to allow refreshing the token if necessary.
*
* @return string One of the following: 'success', 'with_errors', or 'refresh_required'.
*/
private function _delete_chunk( $files, &$results, $allow_refresh_token ) {
list( $result, $listed_files ) = $this->list_files_chunk( $files, $allow_refresh_token );
if ( 'success' !== $result ) {
return $result;
}
foreach ( $listed_files->items as $item ) {
try {
$this->_service->files->delete( $item->id );
$results[] = $this->_get_result(
$item->title,
$item->title,
W3TC_CDN_RESULT_OK,
'OK'
);
} catch ( \Exception $e ) {
$results[] = $this->_get_result(
'',
'',
W3TC_CDN_RESULT_ERROR,
'Failed to delete file ' . $item->title
);
$result = 'with_errors';
continue;
}
}
return $result;
}
/**
* Lists a chunk of files based on the provided file descriptors.
*
* This method lists files matching the specified descriptors, checking if the refresh token is required or if a
* timeout occurred.
*
* @param array $files The file descriptors to list.
* @param bool $allow_refresh_token Flag to allow refreshing the token if necessary.
* @param int|null $timeout_time The timeout time, if any.
*
* @return array Array containing the result status and the listed files.
*
* @throws \W3TCG_Google_Auth_Exception Throws an exception if authentication fails or the listFiles call fails.
*/
private function list_files_chunk( $files, $allow_refresh_token, $timeout_time = null ) {
$titles_filter = array();
try {
foreach ( $files as $file_descriptor ) {
list( $parent_id, $title ) = $this->remote_path_to_title( $file_descriptor['remote_path'] );
$titles_filter[] = '("' . $parent_id . '" in parents and title = "' . $title . '")';
if ( ! is_null( $timeout_time ) && time() > $timeout_time ) {
return array( 'timeout', array() );
}
}
} catch ( \W3TCG_Google_Auth_Exception $e ) {
if ( $allow_refresh_token ) {
return array( 'refresh_required', array() );
}
throw $e;
} catch ( \Exception $e ) {
return array( 'with_errors', array() );
}
// find files.
try {
try {
$listed_files = $this->_service->files->listFiles(
array( 'q' => '(' . join( ' or ', $titles_filter ) . ') and trashed = false' )
);
} catch ( \W3TCG_Google_Auth_Exception $e ) {
if ( $allow_refresh_token ) {
return array( 'refresh_required', array() );
}
throw $e;
}
} catch ( \Exception $e ) {
return array( 'with_errors', array() );
}
return array( 'success', $listed_files );
}
/**
* Converts a remote file path to its title and parent ID.
*
* This method extracts the title and parent folder ID from a remote file path.
*
* @param string $remote_path The remote file path.
*
* @return array An array containing the parent ID and file title.
*/
private function remote_path_to_title( $remote_path ) {
$title = substr( $remote_path, 1 );
$pos = strrpos( $remote_path, '/' );
if ( false === $pos ) {
$path = '';
$title = $remote_path;
} else {
$path = substr( $remote_path, 0, $pos );
$title = substr( $remote_path, $pos + 1 );
}
$title = str_replace( '"', "'", $title );
$parent_id = $this->path_to_parent_id( $this->_root_folder_id, $path );
return array( $parent_id, $title );
}
/**
* Resolves the parent folder ID for a given path.
*
* This method recursively resolves the parent folder ID for a given path within the Google Drive hierarchy.
*
* @param string $root_id The root folder ID.
* @param string $path The folder path to resolve.
*
* @return string The resolved parent folder ID.
*/
private function path_to_parent_id( $root_id, $path ) {
if ( empty( $path ) ) {
return $root_id;
}
$path = ltrim( $path, '/' );
$pos = strpos( $path, '/' );
if ( false === $pos ) {
$top_folder = $path;
$remaining_path = '';
} else {
$top_folder = substr( $path, 0, $pos );
$remaining_path = substr( $path, $pos + 1 );
}
$new_root_id = $this->parent_id_resolve_step( $root_id, $top_folder );
return $this->path_to_parent_id( $new_root_id, $remaining_path );
}
/**
* Resolves the folder ID for a given folder within a parent folder.
*
* This method checks if the folder exists, creates it if necessary, and resolves its ID.
*
* @param string $root_id The parent folder ID.
* @param string $folder The folder name.
*
* @return string The resolved folder ID.
*/
private function parent_id_resolve_step( $root_id, $folder ) {
// decode top folder.
$ids_string = get_transient( 'w3tc_cdn_google_drive_folder_ids' );
$ids = @unserialize( $ids_string );
if ( isset( $ids[ $root_id . '_' . $folder ] ) ) {
return $ids[ $root_id . '_' . $folder ];
}
// find folder.
$items = $this->_service->files->listFiles(
array(
'q' => '"' . $root_id . '" in parents and title = "' . $folder . '" and mimeType = "application/vnd.google-apps.folder" and trashed = false',
)
);
if ( count( $items ) > 0 ) {
$id = $items[0]->id;
} else {
// create folder.
$file = new \W3TCG_Google_Service_Drive_DriveFile(
array(
'title' => $folder,
'mimeType' => 'application/vnd.google-apps.folder',
)
);
$parent = new \W3TCG_Google_Service_Drive_ParentReference();
$parent->setId( $root_id );
$file->setParents( array( $parent ) );
$created_file = $this->_service->files->insert( $file );
$id = $created_file->id;
$permission = new \W3TCG_Google_Service_Drive_Permission();
$permission->setValue( '' );
$permission->setType( 'anyone' );
$permission->setRole( 'reader' );
$this->_service->permissions->insert( $id, $permission );
}
if ( ! is_array( $ids ) ) {
$ids = array();
}
$ids[ $root_id . '_' . $folder ] = $id;
set_transient( 'w3tc_cdn_google_drive_folder_ids', serialize( $ids ) );
return $id;
}
/**
* Runs a test by uploading and then deleting a test file on Google Drive.
*
* This method uploads a test file, and if successful, deletes it, returning an error if either operation fails.
*
* @param string $error The variable to store error messages if any operation fails.
*
* @return bool True on success, false on failure.
*/
public function test( &$error ) {
$test_content = '' . wp_rand();
$file = array(
'local_path' => 'n/a',
'remote_path' => '/folder/test.txt',
'content' => $test_content,
);
$results = array();
if ( ! $this->upload( array( $file ), $results ) ) {
$error = sprintf( 'Unable to upload file %s', $file['remote_path'] );
return false;
}
if ( ! $this->delete( array( $file ), $results ) ) {
$error = sprintf( 'Unable to delete file %s', $file['remote_path'] );
return false;
}
return true;
}
/**
* Returns the domains supported by the Google Drive CDN.
*
* This method returns an empty array since the current implementation does not support specific domains.
*
* @return array An empty array.
*/
public function get_domains() {
return array();
}
/**
* Returns the type of headers supported by the CDN.
*
* This method returns a constant indicating that no custom headers are supported.
*
* @return string One of the constants indicating header support (e.g., `W3TC_CDN_HEADER_NONE`).
*/
public function headers_support() {
return W3TC_CDN_HEADER_NONE;
}
/**
* Purges all cached files from the Google Drive CDN.
*
* This method does not support purging all cached files and will always return false.
*
* @param array $results The array to collect results of the purging operation.
*
* @return bool Always returns false.
*/
public function purge_all( &$results ) {
return false;
}
/**
* Sets the remote ID for a given file path.
*
* This method stores the remote ID associated with a file path in the database.
*
* @param string $path The local file path.
* @param string $id The remote file ID.
*
* @return void
*/
private function path_set_id( $path, $id ) {
global $wpdb;
$md5 = md5( $path );
if ( ! $id ) {
$sql = "INSERT INTO $this->_tablename_pathmap
(path, path_hash, remote_id)
VALUES (%s, %s, NULL)
ON DUPLICATE KEY UPDATE remote_id = NULL";
$wpdb->query( $wpdb->prepare( $sql, $path, $md5 ) );
} else {
$sql = "INSERT INTO $this->_tablename_pathmap
(path, path_hash, remote_id)
VALUES (%s, %s, %s)
ON DUPLICATE KEY UPDATE remote_id = %s";
$wpdb->query( $wpdb->prepare( $sql, $path, $md5, $id, $id ) );
}
}
/**
* Gets the remote ID associated with a file path.
*
* This method retrieves the remote ID for a file path, either from the database or by querying Google Drive.
*
* @param string $path The local file path.
* @param bool $allow_refresh_token Flag to allow refreshing the token if necessary.
*
* @return string|null The remote file ID or null if not found.
*
* @throws \W3TCG_Google_Auth_Exception Throws an exception if authentication fails or the listFiles call fails.
*/
private function path_get_id( $path, $allow_refresh_token = true ) {
global $wpdb;
$md5 = md5( $path );
$sql = "SELECT remote_id FROM $this->_tablename_pathmap WHERE path_hash = %s";
$query = $wpdb->prepare( $sql, $md5 );
$results = $wpdb->get_results( $query );
if ( count( $results ) > 0 ) {
return $results[0]->remote_id;
}
$props = $this->_path_to_properties( $path );
$q = 'trashed = false';
foreach ( $props as $prop ) {
$key = $prop->key;
$value = str_replace( "'", "\\'", $prop->value );
$q .= " and properties has { key='$key' and value='$value' and visibility='PRIVATE' }";
}
try {
$items = $this->_service->files->listFiles( array( 'q' => $q ) );
} catch ( \W3TCG_Google_Auth_Exception $e ) {
if ( $allow_refresh_token ) {
$this->_refresh_token();
return $this->path_get_id( $path, false );
}
throw $e;
}
$id = ( 0 === count( $items ) ) ? null : $items[0]->id;
$this->path_set_id( $path, $id );
return $id;
}
/**
* Formats a URL for accessing a file on Google Drive.
*
* This method returns a URL to access a file on Google Drive based on its remote ID.
*
* @param string $path The local file path.
* @param bool $allow_refresh_token Flag to allow refreshing the token if necessary.
*
* @return string|null The formatted URL or null if the ID could not be retrieved.
*/
public function format_url( $path, $allow_refresh_token = true ) {
$id = $this->path_get_id( Util_Environment::remove_query( $path ) );
if ( is_null( $id ) ) {
return null;
}
return 'https://drive.google.com/uc?id=' . $id;
}
}