PHP AmazonS3::create_bucket方法代码示例

 /**
  * 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));
     }
 }

//.........这里部分代码省略.........
                 }
                 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.');
                 }
             }

 * 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 <jeffrey.haemer@gmail.com>
 */
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);