/** * Gets s3 object * * @param boolean $debug return error message instead of script stop * @return \AmazonS3 s3 object */ public function s3($debug = false) { // This is workaround to composer autoloader if (!class_exists('CFLoader')) { throw new ClassNotFoundException('Amazon: autoload failed'); } if (empty($this->_s3)) { \CFCredentials::set(array('@default' => array('key' => $this->getOption('key'), 'secret' => $this->getOption('secret')))); $this->_s3 = new \AmazonS3(); $this->_s3->use_ssl = false; $this->_buckets = fn_array_combine($this->_s3->get_bucket_list(), true); } $message = ''; $bucket = $this->getOption('bucket'); if (empty($this->_buckets[$bucket])) { $res = $this->_s3->create_bucket($bucket, $this->getOption('region')); if ($res->isOK()) { $res = $this->_s3->create_cors_config($bucket, array('cors_rule' => array(array('allowed_origin' => '*', 'allowed_method' => 'GET')))); if ($res->isOK()) { $this->_buckets[$bucket] = true; } else { $message = (string) $res->body->Message; } } else { $message = (string) $res->body->Message; } } if (!empty($message)) { if ($debug == true) { return $message; } throw new ExternalException('Amazon: ' . $message); } return $this->_s3; }
protected function execute($arguments = array(), $options = array()) { $this->configuration = ProjectConfiguration::getApplicationConfiguration($options['app'], $options['env'], true); if (!sfConfig::get('app_sf_amazon_plugin_access_key', false)) { throw new sfException(sprintf('You have not set an amazon access key')); } if (!sfConfig::get('app_sf_amazon_plugin_secret_key', false)) { throw new sfException(sprintf('You have not set an amazon secret key')); } $s3 = new AmazonS3(sfConfig::get('app_sf_amazon_plugin_access_key'), sfConfig::get('app_sf_amazon_plugin_secret_key')); $this->s3_response = $s3->create_bucket($arguments['bucket'], $options['region'], $options['acl']); if ($this->s3_response->isOk()) { $this->log('Bucketed is being created...'); /* Since AWS follows an "eventual consistency" model, sleep and poll until the bucket is available. */ $exists = $s3->if_bucket_exists($arguments['bucket']); while (!$exists) { // Not yet? Sleep for 1 second, then check again sleep(1); $exists = $s3->if_bucket_exists($arguments['bucket']); } $this->logSection('Bucket+', sprintf('"%s" created successfully', $arguments['bucket'])); } else { throw new sfException($this->s3_response->body->Message); } }
/** * @param $jobid * @return string */ public function edit_form_post_save($jobid) { BackWPup_Option::update($jobid, 's3accesskey', isset($_POST['s3accesskey']) ? $_POST['s3accesskey'] : ''); BackWPup_Option::update($jobid, 's3secretkey', isset($_POST['s3secretkey']) ? BackWPup_Encryption::encrypt($_POST['s3secretkey']) : ''); BackWPup_Option::update($jobid, 's3base_url', isset($_POST['s3base_url']) ? esc_url_raw($_POST['s3base_url']) : ''); BackWPup_Option::update($jobid, 's3region', isset($_POST['s3region']) ? $_POST['s3region'] : ''); BackWPup_Option::update($jobid, 's3storageclass', isset($_POST['s3storageclass']) ? $_POST['s3storageclass'] : ''); BackWPup_Option::update($jobid, 's3ssencrypt', isset($_POST['s3ssencrypt']) && $_POST['s3ssencrypt'] == 'AES256' ? 'AES256' : ''); BackWPup_Option::update($jobid, 's3bucket', isset($_POST['s3bucket']) ? $_POST['s3bucket'] : ''); $_POST['s3dir'] = trailingslashit(str_replace('//', '/', str_replace('\\', '/', trim(stripslashes($_POST['s3dir']))))); if (substr($_POST['s3dir'], 0, 1) == '/') { $_POST['s3dir'] = substr($_POST['s3dir'], 1); } if ($_POST['s3dir'] == '/') { $_POST['s3dir'] = ''; } BackWPup_Option::update($jobid, 's3dir', $_POST['s3dir']); BackWPup_Option::update($jobid, 's3maxbackups', isset($_POST['s3maxbackups']) ? (int) $_POST['s3maxbackups'] : 0); BackWPup_Option::update($jobid, 's3syncnodelete', isset($_POST['s3syncnodelete']) && $_POST['s3syncnodelete'] == 1 ? TRUE : FALSE); BackWPup_Option::update($jobid, 's3multipart', isset($_POST['s3multipart']) && $_POST['s3multipart'] == 1 ? TRUE : FALSE); //create new bucket if (!empty($_POST['s3newbucket'])) { try { $s3 = new AmazonS3(array('key' => $_POST['s3accesskey'], 'secret' => BackWPup_Encryption::decrypt($_POST['s3secretkey']), 'certificate_authority' => TRUE)); $base_url = $this->get_s3_base_url($_POST['s3region'], $_POST['s3base_url']); if (stristr($base_url, 'amazonaws.com')) { $s3->set_region(str_replace(array('http://', 'https://'), '', $base_url)); } else { $s3->set_hostname(str_replace(array('http://', 'https://'), '', $base_url)); $s3->allow_hostname_override(FALSE); if (substr($base_url, -1) == '/') { $s3->enable_path_style(TRUE); } } if (stristr($base_url, 'http://')) { $s3->disable_ssl(); } // set bucket creation region if ($_POST['s3region'] == 'google-storage' || $_POST['s3region'] == 'hosteurope') { $region = 'EU'; } else { $region = str_replace(array('http://', 'https://'), '', $base_url); } $bucket = $s3->create_bucket($_POST['s3newbucket'], $region, 'private'); if ($bucket->status == 200) { BackWPup_Admin::message(sprintf(__('Bucket %1$s created in %2$s.', 'backwpup'), $_POST['s3newbucket'], $bucket['Location'])); } else { BackWPup_Admin::message(sprintf(__('Bucket %s could not be created.', 'backwpup'), $_POST['s3newbucket']), TRUE); } } catch (Exception $e) { BackWPup_Admin::message($e->getMessage(), TRUE); } BackWPup_Option::update($jobid, 's3bucket', $_POST['s3newbucket']); } }
<?php // Inizializzo la classe AmazonS3 $s3 = new AmazonS3(); // Creo un bucket per la memorizzazione di un file $response = $s3->create_bucket('my-bucket', AmazonS3::REGION_US_E1); if (!$response->isOK()) { die('Errore durante la creazione del bucket'); } $data = file_get_contents('/my/local/dir/picture.jpg'); $response = $s3->create_object('my-bucket', 'picture.jpg', array('body' => $data)); if (!$response->isOK()) { die('Errore durante la memorizzazione del file'); } echo "Il file è stato memorizzato con successo";
$jobvalues['awsBucket'] = $_POST['newawsBucket']; } catch (Exception $e) { $backwpup_message .= __($e->getMessage(), 'backwpup') . '<br />'; } } if (!empty($_POST['GStorageAccessKey']) and !empty($_POST['GStorageSecret']) and !empty($_POST['newGStorageBucket'])) { //create new google storage bucket if needed if (!class_exists('CFRuntime')) { require_once dirname(__FILE__) . '/../libs/aws/sdk.class.php'; } try { CFCredentials::set(array('backwpup' => array('key' => $_POST['GStorageAccessKey'], 'secret' => $_POST['GStorageSecret'], 'default_cache_config' => '', 'certificate_authority' => true), '@default' => 'backwpup')); $gstorage = new AmazonS3(); $gstorage->set_hostname('storage.googleapis.com'); $gstorage->allow_hostname_override(false); $gstorage->create_bucket($_POST['newGStorageBucket'], ''); $jobvalues['GStorageBucket'] = $_POST['newGStorageBucket']; sleep(1); //creation take a moment } catch (Exception $e) { $backwpup_message .= __($e->getMessage(), 'backwpup') . '<br />'; } } if (!empty($_POST['newmsazureContainer']) and !empty($_POST['msazureHost']) and !empty($_POST['msazureAccName']) and !empty($_POST['msazureKey'])) { //create new s3 bucket if needed if (!class_exists('Microsoft_WindowsAzure_Storage_Blob')) { require_once dirname(__FILE__) . '/../libs/Microsoft/WindowsAzure/Storage/Blob.php'; } try { $storageClient = new Microsoft_WindowsAzure_Storage_Blob($_POST['msazureHost'], $_POST['msazureAccName'], $_POST['msazureKey']); $result = $storageClient->createContainer($_POST['newmsazureContainer']);
/** * Attempt to create the bucket for the given region * * @param string $region * @return bool */ public function createBucket($region = AmazonS3::REGION_US_W1) { $response = $this->s3->create_bucket($this->bucket, $region); return $response->isOK() ? true : false; }
/*%******************************************************************************************%*/ // SETUP // Enable full-blown error reporting. http://twitter.com/rasmus/status/7448448829 error_reporting(-1); // Set plain text headers header("Content-type: text/plain; charset=utf-8"); // Include the SDK require_once '../sdk.class.php'; /*%******************************************************************************************%*/ // UPLOAD FILES TO S3 // Instantiate the AmazonS3 class $s3 = new AmazonS3(); // Determine a completely unique bucket name (all lowercase) $bucket = 'php-sdk-getting-started-' . strtolower($s3->key) . '-' . time(); // Create our new bucket in the US-West region. $create_bucket_response = $s3->create_bucket($bucket, AmazonS3::REGION_US_W1); // Provided that the bucket was created successfully... if ($create_bucket_response->isOK()) { /* Since AWS follows an "eventual consistency" model, sleep and poll until the bucket is available. */ $exists = $s3->if_bucket_exists($bucket); while (!$exists) { // Not yet? Sleep for 1 second, then check again sleep(1); $exists = $s3->if_bucket_exists($bucket); } /* Get a list of files to upload. We'll use some helper functions we've defined below. This assumes that you have a directory called "test_files" that actually contains some files you want to upload. */
public function createAmazonBucketName($name) { $name = strtolower($name); ProjectConfiguration::registerAws(); $s3 = new AmazonS3(); if (!$s3->if_bucket_exists($name)) { $s3->create_bucket($name, AmazonS3::REGION_US_E1, AmazonS3::ACL_AUTH_READ); $exists = $s3->if_bucket_exists($name); $attempts = 0; while (!$exists && $attempts < 10) { // Not yet? Sleep for 1 second, then check again sleep(1); $exists = $s3->if_bucket_exists($name); $attempts++; } if (!$exists) { $cdn = new AmazonCloudFront(); $cdn->create_distribution($name, md5('caller_reference_' . microtime())); } return $name; } $response = $s3->get_bucket_policy($name); if (in_array($response->status, array(403, 405))) { return $this->createAmazonBucketName($name . rand(0, 1000)); } }
public static function send($settings = array(), $files = array(), $clear_uploads = false) { // TODO: Currently force prevenrt aborting as we dont allow chunking yet as we must take care to not leave danging multipart uploads as they charge the user. $clear_uploads = false; global $pb_backupbuddy_destination_errors; if (!is_array($files)) { $files = array($files); } if ($clear_uploads === false) { // Uncomment the following line to override and always clear. //$clear_uploads = true; } $db_archive_limit = $settings['db_archive_limit']; $full_archive_limit = $settings['full_archive_limit']; $max_chunk_size = $settings['max_chunk_size']; $remote_path = self::get_remote_path($settings['directory']); // Has leading and trailng slashes. if ($settings['ssl'] == '0') { $disable_ssl = true; } else { $disable_ssl = false; } $multipart_id = $settings['_multipart_id']; $multipart_counts = $settings['_multipart_counts']; pb_backupbuddy::status('details', 'Stash remote path set to `' . $remote_path . '`.'); require_once dirname(dirname(__FILE__)) . '/_s3lib/aws-sdk/sdk.class.php'; $manage_data = self::get_manage_data($settings); // Wipe all current uploads. if ($clear_uploads === true) { pb_backupbuddy::status('details', 'Clearing any current uploads via Stash call to `abort-all`.'); $abort_url = $stash->get_upload_url(null, 'abort-all'); $request = new RequestCore($abort_url); //pb_backupbuddy::status('details', print_r( $request , true ) ); $response = $request->send_request(true); } // Process multipart transfer that we already initiated in a previous PHP load. if ($multipart_id != '') { // Multipart upload initiated and needs parts sent. // Create S3 instance. pb_backupbuddy::status('details', 'Creating Stash S3 instance.'); $s3 = new AmazonS3($settings['_multipart_upload_data']['credentials']); // the key, secret, token if ($disable_ssl === true) { @$s3->disable_ssl(true); } pb_backupbuddy::status('details', 'Stash S3 instance created.'); $this_part_number = $settings['_multipart_partnumber'] + 1; pb_backupbuddy::status('details', 'Stash beginning upload of part `' . $this_part_number . '` of `' . count($settings['_multipart_counts']) . '` parts of file `' . $settings['_multipart_file'] . '` with multipart ID `' . $settings['_multipart_id'] . '`.'); $response = $s3->upload_part($settings['_multipart_upload_data']['bucket'], $settings['_multipart_upload_data']['object'], $settings['_multipart_id'], array('expect' => '100-continue', 'fileUpload' => $settings['_multipart_file'], 'partNumber' => $this_part_number, 'seekTo' => (int) $settings['_multipart_counts'][$settings['_multipart_partnumber']]['seekTo'], 'length' => (int) $settings['_multipart_counts'][$settings['_multipart_partnumber']]['length'])); if (!$response->isOK()) { $this_error = 'Stash unable to upload file part for multipart upload `' . $settings['_multipart_id'] . '`. Details: `' . print_r($response, true) . '`.'; $pb_backupbuddy_destination_errors[] = $this_error; pb_backupbuddy::status('error', $this_error); return false; } // Update stats. foreach (pb_backupbuddy::$options['remote_sends'] as $identifier => $remote_send) { if (isset($remote_send['_multipart_id']) && $remote_send['_multipart_id'] == $multipart_id) { // this item. pb_backupbuddy::$options['remote_sends'][$identifier]['_multipart_status'] = 'Sent part ' . $this_part_number . ' of ' . count($settings['_multipart_counts']) . '.'; if ($this_part_number == count($settings['_multipart_counts'])) { pb_backupbuddy::$options['remote_sends'][$identifier]['_multipart_status'] .= '<br>Success.'; pb_backupbuddy::$options['remote_sends'][$identifier]['finish_time'] = time(); } pb_backupbuddy::save(); break; } } // Made it here so success sending part. Increment for next part to send. $settings['_multipart_partnumber']++; if (!isset($settings['_multipart_counts'][$settings['_multipart_partnumber']])) { // No more parts exist for this file. Tell S3 the multipart upload is complete and move on. pb_backupbuddy::status('details', 'Stash getting parts with etags to notify S3 of completed multipart send.'); $etag_parts = $s3->list_parts($settings['_multipart_upload_data']['bucket'], $settings['_multipart_upload_data']['object'], $settings['_multipart_id']); pb_backupbuddy::status('details', 'Stash got parts list. Notifying S3 of multipart upload completion.'); $response = $s3->complete_multipart_upload($settings['_multipart_upload_data']['bucket'], $settings['_multipart_upload_data']['object'], $settings['_multipart_id'], $etag_parts); if (!$response->isOK()) { $this_error = 'Stash unable to notify S3 of completion of all parts for multipart upload `' . $settings['_multipart_id'] . '`.'; $pb_backupbuddy_destination_errors[] = $this_error; pb_backupbuddy::status('error', $this_error); return false; } else { pb_backupbuddy::status('details', 'Stash notified S3 of multipart completion.'); } // Notify Stash API that things were succesful. $done_url = $stash->get_upload_url($settings['_multipart_file'], 'done', $remote_path . $settings['_multipart_backup_type_dir'] . basename($settings['_multipart_file'])); pb_backupbuddy::status('details', 'Notifying Stash of completed multipart upload with done url `' . $done_url . '`.'); $request = new RequestCore($done_url); $response = $request->send_request(true); if (!$response->isOK()) { $this_error = 'Error #753236834682. Could not finalize Stash upload. Response code: `' . $response->get_response_code() . '`; Response body: `' . $response->get_response_body() . '`; Response headers: `' . $response->get_response_header() . '`.'; $pb_backupbuddy_destination_errors[] = $this_error; pb_backupbuddy::status('error', $this_error); return false; } else { // Good server response. // See if we got an optional json response. $upload_data = @json_decode($response->body, true); if (isset($upload_data['error'])) { $this_error = 'Stash error(s): `' . implode(' - ', $upload_data['error']) . '`.'; $pb_backupbuddy_destination_errors[] = $this_error; pb_backupbuddy::status('error', $this_error); return false; } pb_backupbuddy::status('details', 'Stash success sending file `' . basename($settings['_multipart_file']) . '`. File uploaded via multipart across `' . $this_part_number . '` parts and reported to Stash as completed.'); } pb_backupbuddy::status('details', 'Stash has no more parts left for this multipart upload. Clearing multipart instance variables.'); $settings['_multipart_partnumber'] = 0; $settings['_multipart_id'] = ''; $settings['_multipart_file'] = ''; $settings['_multipart_counts'] = array(); $settings['_multipart_upload_data'] = array(); } delete_transient('pb_backupbuddy_stashquota_' . $settings['itxapi_username']); // Delete quota transient since it probably has changed now. // Schedule to continue if anything is left to upload for this multipart of any individual files. if ($settings['_multipart_id'] != '' || count($files) > 0) { pb_backupbuddy::status('details', 'Stash multipart upload has more parts left. Scheduling next part send.'); pb_backupbuddy::$classes['core']->schedule_single_event(time(), pb_backupbuddy::cron_tag('destination_send'), array($settings, $files, 'multipart', false)); spawn_cron(time() + 150); // Adds > 60 seconds to get around once per minute cron running limit. update_option('_transient_doing_cron', 0); // Prevent cron-blocking for next item. pb_backupbuddy::status('details', 'Stash scheduled send of next part(s). Done for this cycle.'); return array($settings['_multipart_id'], 'Sent ' . $this_part_number . ' of ' . count($multipart_destination_settings['_multipart_counts'] . ' parts.')); } } // Create S3 instance. pb_backupbuddy::status('details', 'Creating S3 instance.'); $s3 = new AmazonS3(self::get_manage_data($settings)); // the key, secret, token if ($disable_ssl === true) { @$s3->disable_ssl(true); } pb_backupbuddy::status('details', 'Stash S3 instance created.'); // Verify bucket exists. $response = $s3->create_bucket($settings['bucket'], 's3.amazonaws.com'); require_once pb_backupbuddy::plugin_path() . '/classes/fileoptions.php'; // Upload each file. foreach ($files as $file_id => $file) { // Determine backup type directory (if zip). $backup_type_dir = ''; $backup_type = ''; if (stristr($file, '.zip') !== false) { // If a zip try to determine backup type. // See if we can get backup type from fileoptions data. $backup_options = new pb_backupbuddy_fileoptions(pb_backupbuddy::$options['log_directory'] . 'fileoptions/' . $serial . '.txt', $read_only = true); if (true !== ($result = $backup_options->is_ok())) { pb_backupbuddy::status('error', 'Unable to open fileoptions file.'); } else { if (isset($backup_options->options['integrity']['detected_type'])) { pb_backupbuddy::status('details', 'S3: Detected backup type as `' . $backup_options->options['integrity']['detected_type'] . '` via integrity check data.'); $backup_type_dir = $backup_options->options['integrity']['detected_type'] . '/'; $backup_type = $backup_options->options['integrity']['detected_type']; } } if ('' == $backup_type) { if (stristr($file, '-db-') !== false) { pb_backupbuddy::status('details', 'Stash: Detected backup type as `db` via filename.'); $backup_type_dir = 'db/'; $backup_type = 'db'; } elseif (stristr($file, '-full-') !== false) { pb_backupbuddy::status('details', 'Stash: Detected backup type as `full` via filename.'); $backup_type_dir = 'full/'; $backup_type = 'full'; } else { pb_backupbuddy::status('details', 'Stash: Could not detect backup type via integrity details nor filename.'); } } } // Handle chunking of file into a multipart upload (if applicable). $file_size = filesize($file); if ($max_chunk_size >= 5 && $file_size / 1024 / 1024 > $max_chunk_size) { // minimum chunk size is 5mb. Anything under 5mb we will not chunk. pb_backupbuddy::status('details', 'Stash file size of ' . $file_size / 1024 / 1024 . 'MB exceeds max chunk size of ' . $max_chunk_size . 'MB set in settings for sending file as multipart upload.'); // Initiate multipart upload with S3. pb_backupbuddy::status('details', 'Initiating Stash multipart upload.'); $response = $s3->initiate_multipart_upload($upload_data['bucket'], $upload_data['object'], array('encryption' => $settings['server_encryption'])); if (!$response->isOK()) { $this_error = 'Stash was unable to initiate multipart upload.'; $pb_backupbuddy_destination_errors[] = $this_error; pb_backupbuddy::status('error', $this_error); return false; } else { $upload_id = (string) $response->body->UploadId; pb_backupbuddy::status('details', 'Stash initiated multipart upload with ID `' . $upload_id . '`.'); } // Get chunk parts for multipart transfer. pb_backupbuddy::status('details', 'Stash getting multipart counts.'); $parts = $s3->get_multipart_counts($file_size, $max_chunk_size * 1024 * 1024); // Size of chunks expected to be in bytes. $multipart_destination_settings = $settings; $multipart_destination_settings['_multipart_id'] = $upload_id; $multipart_destination_settings['_multipart_partnumber'] = 0; $multipart_destination_settings['_multipart_file'] = $file; $multipart_destination_settings['_multipart_counts'] = $parts; $multipart_destination_settings['_multipart_upload_data'] = $upload_data; $multipart_destination_settings['_multipart_backup_type_dir'] = $backup_type_dir; pb_backupbuddy::status('details', 'Stash multipart settings to pass:'******'details', 'Stash scheduling send of next part(s).'); pb_backupbuddy::$classes['core']->schedule_single_event(time(), pb_backupbuddy::cron_tag('destination_send'), array($multipart_destination_settings, $files, 'multipart', false)); spawn_cron(time() + 150); // Adds > 60 seconds to get around once per minute cron running limit. update_option('_transient_doing_cron', 0); // Prevent cron-blocking for next item. pb_backupbuddy::status('details', 'Stash scheduled send of next part(s). Done for this cycle.'); return array($upload_id, 'Starting send of ' . count($multipart_destination_settings['_multipart_counts']) . ' parts.'); } else { if ($max_chunk_size != '0') { pb_backupbuddy::status('details', 'File size of ' . $file_size / 1024 / 1024 . 'MB is less than the max chunk size of ' . $max_chunk_size . 'MB; not chunking into multipart upload.'); } else { pb_backupbuddy::status('details', 'Max chunk size set to zero so not chunking into multipart upload.'); } } // SEND file. pb_backupbuddy::status('details', 'About to put (upload) object to S3.'); $response = $s3->create_object($settings['bucket'], $remote_path . basename($file), array('fileUpload' => $file, 'encryption' => $settings['server_encryption'])); // Validate response. On failure notify Stash API that things went wrong. if (!$response->isOK()) { $this_error = 'Error #752323446834682. Could not send to S3. Body: `' . $response->body . '`; Header: `' . print_r($response->header, true) . '`; Status: `' . $response->status . '`;'; $pb_backupbuddy_destination_errors[] = $this_error; pb_backupbuddy::status('error', $this_error); return false; } else { pb_backupbuddy::status('details', 'S3 put success. Details: `' . print_r($response, true) . '`.'); } delete_transient('pb_backupbuddy_stashquota_' . $settings['itxapi_username']); // Delete quota transient since it probably has changed now. // Notify Stash API that things were succesful. $done_url = $stash->get_upload_url($file, 'done', $remote_path . $backup_type_dir . basename($file)); pb_backupbuddy::status('details', 'Notifying Stash of completed upload with done url `' . $done_url . '`.'); $request = new RequestCore($done_url); $response = $request->send_request(true); if (!$response->isOK()) { $this_error = 'Error #7568849984434682. Could not finalize Stash upload. Response code: `' . $response->get_response_code() . '`; Response body: `' . $response->get_response_body() . '`; Response headers: `' . $response->get_response_header() . '`.'; $pb_backupbuddy_destination_errors[] = $this_error; pb_backupbuddy::status('error', $this_error); return false; } else { // Good server response. // See if we got an optional json response. $upload_data = @json_decode($response->body, true); if (isset($upload_data['error'])) { // Some kind of error. $this_error = 'Stash error(s): `' . implode(' - ', $upload_data['error']) . '`.'; $pb_backupbuddy_destination_errors[] = $this_error; pb_backupbuddy::status('error', $this_error); return false; } unset($files[$file_id]); // Remove from list of files we have not sent yet. pb_backupbuddy::status('details', 'Stash success sending file `' . basename($file) . '`. File uploaded and reported to Stash as completed.'); } // Enforce archive limits if applicable. if ($backup_type == 'full') { $limit = $full_archive_limit; pb_backupbuddy::status('details', 'Stash full backup archive limit of `' . $limit . '` based on destination settings.'); } elseif ($backup_type == 'db') { $limit = $db_archive_limit; pb_backupbuddy::status('details', 'Stash database backup archive limit of `' . $limit . '` based on destination settings.'); } else { $limit = 0; pb_backupbuddy::status('error', 'Error #54854895. Stash was unable to determine backup type so archive limits NOT enforced for this backup.'); } if ($limit > 0) { pb_backupbuddy::status('details', 'Stash archive limit enforcement beginning.'); // S3 object for managing files. $s3_manage = new AmazonS3($manage_data['credentials']); if ($disable_ssl === true) { @$s3_manage->disable_ssl(true); } // Get file listing. $response_manage = $s3_manage->list_objects($manage_data['bucket'], array('prefix' => $manage_data['subkey'] . $remote_path . $backup_type_dir)); // list all the files in the subscriber account // Create array of backups and organize by date $prefix = pb_backupbuddy::$classes['core']->backup_prefix(); // List backups associated with this site by date. $backups = array(); foreach ($response_manage->body->Contents as $object) { $file = str_replace($manage_data['subkey'] . $remote_path . $backup_type_dir, '', $object->Key); // Stash stores files in a directory per site so no need to check prefix here! if ( false !== strpos( $file, 'backup-' . $prefix . '-' ) ) { // if backup has this site prefix... $backups[$file] = strtotime($object->LastModified); //} } arsort($backups); //error_log( 'backups: ' . print_r( $backups, true ) ); pb_backupbuddy::status('details', 'Stash found `' . count($backups) . '` backups of this type when checking archive limits.'); if (count($backups) > $limit) { pb_backupbuddy::status('details', 'More archives (' . count($backups) . ') than limit (' . $limit . ') allows. Trimming...'); $i = 0; $delete_fail_count = 0; foreach ($backups as $buname => $butime) { $i++; if ($i > $limit) { pb_backupbuddy::status('details', 'Trimming excess file `' . $buname . '`...'); $response = $s3_manage->delete_object($manage_data['bucket'], $manage_data['subkey'] . $remote_path . $backup_type_dir . $buname); if (!$response->isOK()) { pb_backupbuddy::status('details', 'Unable to delete excess Stash file `' . $buname . '`. Details: `' . print_r($response, true) . '`.'); $delete_fail_count++; } } } pb_backupbuddy::status('details', 'Finished trimming excess backups.'); if ($delete_fail_count !== 0) { $error_message = 'Stash remote limit could not delete ' . $delete_fail_count . ' backups.'; pb_backupbuddy::status('error', $error_message); pb_backupbuddy::$classes['core']->mail_error($error_message); } } pb_backupbuddy::status('details', 'Stash completed archive limiting.'); } else { pb_backupbuddy::status('details', 'No Stash archive file limit to enforce.'); } // End remote backup limit } // end foreach. // Success if we made it this far. return true; }
* of the License is located at * * http://aws.amazon.com/apache2.0/ * * or in the "license.txt" file accompanying this file. This file is * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS * OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the * License. * * Modified by Jeffrey S. Haemer <*****@*****.**> */ error_reporting(E_ALL); require_once 'AWSSDKforPHP/sdk.class.php'; require_once 'include/book.inc.php'; if ($argc != 2) { exit("Usage: " . $argv[0] . " bucket name\n"); } $bucket = $argv[1] == '-' ? BOOK_BUCKET : $argv[1]; // Create the S3 access object $s3 = new AmazonS3(); // Create an S3 bucket $res = $s3->create_bucket($bucket, AmazonS3::REGION_US_E1); // Report on status if ($res->isOK()) { print "'{$bucket}' bucket created\n"; } else { print "Error creating bucket '{$bucket}'\n"; print_r($res); } exit(0);