/**
  * Uploads string as file to s3
  * @param $name
  * @param $content
  * @param string $contentType
  * @return string
  */
 public function uploadString($name, $content, $contentType = 'text/plain')
 {
     $s3FileName = $this->getFilePathAndUniquePrefix() . $name;
     list($bucket, $prefix) = explode('/', $this->s3path, 2);
     $this->s3client->putObject(['Bucket' => $bucket, 'Key' => (empty($prefix) ? '' : trim($prefix, '/') . '/') . $s3FileName, 'ContentType' => $contentType, 'ACL' => 'private', 'ServerSideEncryption' => 'AES256', 'Body' => $content]);
     return $this->withUrlPrefix($s3FileName);
 }
Example #2
0
 /**
  * Write data to a specific relative location
  *
  * @param mixed $data Data to be written
  * @param string $filename File name
  * @param string $uploadDir Relative file path
  * @return string Relative path to created file, false if there were errors
  */
 public function write($data, $filename = '', $uploadDir = '')
 {
     // Upload data to Amazon S3
     $this->client->putObject(array('Bucket' => $this->bucket, 'Key' => $uploadDir . '/' . $filename, 'Body' => $data, 'CacheControl' => 'max-age=' . $this->maxAge, 'ACL' => 'public-read'));
     // Build absolute path to uploaded resource
     return $this->bucketURL . '/' . (isset($uploadDir[0]) ? $uploadDir . '/' : '');
 }
 public function putObject($bucket, $key, $filePath, $options)
 {
     $options['Bucket'] = $bucket;
     $options['Key'] = $key;
     $options['Body'] = EntityBody::factory(fopen($filePath, 'r+'));
     return $this->s3->putObject($options);
 }
Example #4
0
 /**
  * {@inheritdoc}
  */
 public function put($path, $data)
 {
     try {
         $this->s3->putObject(['Bucket' => $this->bucket, 'Key' => $path, 'Body' => $data]);
     } catch (AwsExceptionInterface $e) {
         throw Exception\StorageException::putError($path, $e);
     }
 }
Example #5
0
 /**
  * Move an uploaded file to it's intended destination.
  *
  * @param  string $file
  * @param  string $filePath
  */
 public function move($file, $filePath)
 {
     $objectConfig = $this->attachedFile->s3_object_config;
     $fileSpecificConfig = ['Key' => $filePath, 'SourceFile' => $file, 'ContentType' => $this->attachedFile->contentType()];
     $mergedConfig = array_merge($objectConfig, $fileSpecificConfig);
     $this->ensureBucketExists($mergedConfig['Bucket']);
     $this->s3Client->putObject($mergedConfig);
 }
 /**
  * @param string          $path
  * @param string|resource $data
  * @param string          $contentType
  *
  * @return bool
  * @throws FileException
  */
 public function save($path, $data, $contentType = null)
 {
     try {
         $this->s3->putObject(['Bucket' => $this->bucket, 'Key' => $path, 'Body' => $data, 'ContentType' => $contentType]);
     } catch (\Exception $e) {
         throw new FileException('Unable to save file', $e->getCode(), $e);
     }
     return true;
 }
Example #7
0
 public function set($key, $value, $ttl = null)
 {
     $this->load();
     try {
         $this->s3Client->putObject(["Bucket" => S3Cache::BUCKET, "Key" => $key, "Body" => $value, "Expires" => $this->ttlToDateTime($ttl, $this->defaultTTL)]);
     } catch (\Exception $e) {
         throw new \RuntimeException("Unable to set object in S3Cache '{$key}''");
     }
 }
Example #8
0
 /**
  * @param $filename
  * @param $filePath
  * @param string $mimeType
  * @return \Aws\Result|null
  */
 public function upload($filename, $filePath, $mimeType = 'image/jpeg')
 {
     $result = null;
     try {
         $result = $this->s3->putObject(['Bucket' => $this->bucket, 'Key' => $filename, 'SourceFile' => $filePath, 'ACL' => self::ACL_PRIVATE_READ, 'ContentType' => $mimeType]);
     } catch (\Exception $e) {
     }
     return $result;
 }
Example #9
0
 /**
  * S3の指定パスへファイルをアップロードする
  *
  * @param  string $from_path
  * @param  string $to_path
  * @return void
  **/
 public function upload($from_path, $to_path)
 {
     try {
         $this->client->putObject(array('Bucket' => $this->bucket, 'Key' => $to_path, 'Body' => EntityBody::factory(fopen($from_path, 'r'))));
     } catch (\Exception $e) {
         throw $e;
     }
     return true;
 }
 /**
  * {@inheritDoc}
  */
 public function store(BinaryInterface $binary, $path, $filter)
 {
     $objectPath = $this->getObjectPath($path, $filter);
     try {
         $this->storage->putObject(array('ACL' => $this->acl, 'Bucket' => $this->bucket, 'Key' => $objectPath, 'Body' => $binary->getContent(), 'ContentType' => $binary->getMimeType()));
     } catch (\Exception $e) {
         $this->logError('The object could not be created on Amazon S3.', array('objectPath' => $objectPath, 'filter' => $filter, 'bucket' => $this->bucket, 'exception' => $e));
         throw new NotStorableException('The object could not be created on Amazon S3.', null, $e);
     }
 }
 /**
  * @param string $html the content to be uploaded.
  * @return string the URL of the uploaded content.
  */
 public function uploadHtml($headers, $html)
 {
     $file = date('YmdHis-') . uniqid("", true);
     $key = (!empty($this->directoryPath) ? $this->directoryPath . '/' : '') . $file . '.html';
     $url = $this->_client->getObjectUrl($this->bucket, $key);
     $result = $this->_client->putObject(array_merge(['ACL' => 'public-read', 'Bucket' => $this->bucket, 'Body' => str_replace($this->archiveUrlTag, $url, $html), 'CacheControl' => 'max-age=31536000, public', 'ContentType' => 'text/html', 'Key' => $key, 'Metadata' => ['X-UID-MailHeader' => \yii\helpers\Json::encode($headers)], 'Expires' => gmdate('D, d M Y H:i:s \\G\\M\\T', strtotime('+5 year'))], $this->uploadOptions));
     if ($result) {
         return $url;
     } else {
         return false;
     }
 }
 public function uploadMedia(Media $media, $acl = 'public-read')
 {
     $targetPath = parse_url($media->getUrl(), PHP_URL_PATH);
     if ($media->getUrl() === $targetPath) {
         throw new \InvalidArgumentException('Media has to have a public URL set before uploading');
     }
     if (null === $media->getContent()) {
         throw new \RuntimeException('Dunno how to get file contents');
     }
     $fd = fopen($media->getContent()->getRealPath(), 'rb');
     $storageResponse = $this->storage->putObject(['ACL' => $acl, 'Bucket' => $this->bucketName, 'Key' => ltrim($targetPath, '/'), 'Body' => $fd, 'ContentType' => $media->getContentType(), 'CacheControl' => 'public, max-age=283824000', 'Expires' => gmdate('D, d M Y H:i:s T', strtotime('+9 years'))]);
     fclose($fd);
     return $storageResponse->get('ObjectURL');
 }
 /**
  * {@inheritDoc}
  *
  * @link http://docs.aws.amazon.com/AmazonS3/latest/dev/UploadObjSingleOpPHP.html
  */
 public function store($content)
 {
     $relativePath = $this->generateStoragePath($content);
     $absolutePath = $this->getConfigRelativeKey('s3BucketSubfolder') . '/' . $relativePath;
     // Note: The S3 doesS3ObjectExist method has a problem when the object doesn't exist within the sdk, so we skip this check for now
     // if(! $this->doesS3ObjectExist($this->getConfigRelativeKey('s3Bucket'),, $absolutePath)) {
     try {
         $this->s3->putObject(array('Bucket' => $this->getConfigRelativeKey('s3Bucket'), 'Key' => $absolutePath, 'Body' => $content));
     } catch (S3Exception $e) {
         echo "There was an error uploading the file: " . $e->getMessage() . PHP_EOL;
         $absolutePath = false;
     }
     // }
     return $absolutePath;
 }
 /**
  * @depends testPutAndListObjects
  */
 public function testPutObjectsWithUtf8Keys()
 {
     self::log("Uploading an object with a UTF-8 key");
     $key = 'åbc';
     $this->client->putObject(array('Bucket' => $this->bucket, 'Key' => $key, 'Body' => 'hi'));
     $this->client->waitUntil('object_exists', "{$this->bucket}/{$key}");
 }
 /**
  * @param string $file_filename
  * @param string $fileDe
  * @param string $filePara
  * @param string $file_mimetype
  * @param string $acl
  * @return \Guzzle\Service\Resource\Model
  */
 public function send($file_filename, $fileDe, $filePara, $file_mimetype = null, $acl = \Aws\S3\Enum\CannedAcl::PUBLIC_READ)
 {
     if ($file_mimetype == null) {
         $file_mimetype = $this->getMimeType($file_filename);
     }
     $filePara = str_replace('/_s/', '/', $filePara);
     if (!class_exists('S3Util')) {
         require_once __DIR__ . '/S3Util.php';
     }
     $sendObject = array('Bucket' => $this->bucket_name, 'SourceFile' => $fileDe, 'Key' => S3Util::getPrefix() . $filePara, 'ACL' => $acl, 'CacheControl' => 'max-age=1296000', 'Expires' => date('r', mktime(0, 0, 0, date('m'), date('d'), date('Y') + 10)), 'Etag' => md5($filePara), 'ContentType' => $file_mimetype, 'StorageClass' => \Aws\S3\Enum\StorageClass::STANDARD, 'ContentDisposition' => 'filename="' . $file_filename . '"');
     try {
         return $this->client->putObject($sendObject);
     } catch (Exception $e) {
     }
     return null;
 }
Example #16
0
 /**
  * Write using a stream
  *
  * @param   string    $path
  * @param   resource  $resource
  * @param   mixed     $config
  *
  * @return  array     file metadata
  */
 public function writeStream($path, $resource, $config = null)
 {
     $config = Util::ensureConfig($config);
     $options = $this->getOptions($path, array('Body' => $resource), $config);
     $this->client->putObject($options);
     return $this->normalizeObject($options);
 }
 public function submitForm(array &$form, FormStateInterface $form_state)
 {
     $category = $form_state->getValue('category');
     $header_bg = $form_state->getValue('header_bg')[0];
     $fid = $form_state->getValue('header_bg')[0];
     $filename = db_select('file_managed', 'f')->condition('f.fid', $fid, '=')->fields('f', array('filename'))->execute()->fetchField();
     $data = db_select('file_managed', 'f')->condition('f.fid', $fid, '=')->fields('f', array('uri'))->execute()->fetchField();
     $config = $this->config('amazons.settings');
     $AccessKeyId = $config->get('AccessKeyId');
     $SecretAccessKey = $config->get('SecretAccessKey');
     $region = $config->get('region');
     $bucket = $config->get('bucketname');
     $s3Client = new \Aws\S3\S3Client(['version' => 'latest', 'region' => $region, 'credentials' => ['key' => $AccessKeyId, 'secret' => $SecretAccessKey]]);
     //Creating bucket dynamically
     // $result1 = $s3Client->createBucket(array('Bucket' => 'mybucket'));
     //
     // echo "<pre>";
     // print_r($result1);
     // exit;
     //$bucket = 'ncdfiles';
     $key = date('ymdhis') . time() . $filename;
     //$data = 'public://ncdfiles/' . $filename;
     $result = $s3Client->putObject(array('Bucket' => $bucket, 'Key' => $key, 'SourceFile' => $data, 'ACL' => 'public-read'));
     db_insert('amazon_s3_data')->fields(array('cat_name' => $category, 'file_path' => $result['ObjectURL'], 'fid' => $fid))->execute();
     drupal_set_message('File uploaded to AWS server');
     return;
 }
Example #18
0
 /**
  * Write data to a file.
  *
  * @param  string                $file
  * @param  string|array|resource $data
  * @return boolean
  * @throws \RuntimeException
  */
 public function write($file, $data)
 {
     if (null !== $this->filenameFilter) {
         $file = $this->filenameFilter->filter($file);
     }
     if (is_resource($data)) {
         $type = $this->getMimeTypeDetector()->detectFromResource($data);
     } else {
         if (is_array($data)) {
             $data = implode('', $data);
         }
         $type = $this->getMimeTypeDetector()->detectFromString($data);
     }
     $params = array('Bucket' => $this->getBucket(), 'Key' => $file, 'Body' => $data, 'ACL' => $this->getAcl(), 'StorageClass' => $this->getStorageClass());
     if (!empty($type)) {
         $params['ContentType'] = $type;
     }
     try {
         $this->s3Client->putObject($params);
     } catch (S3Exception $e) {
         if (!$this->getThrowExceptions()) {
             return false;
         }
         throw new \RuntimeException('Exception thrown by Aws\\S3\\S3Client: ' . $e->getMessage(), null, $e);
     }
     return true;
 }
Example #19
0
 /**
  * Write a string to a file
  *
  * @param  string  $path     file path
  * @param  string  $content  new file content
  * @return bool
  * @author Dmitry (dio) Levashov
  **/
 protected function _filePutContents($path, $content)
 {
     $newkey = $this->_normpath($path);
     $newkey = preg_replace("/\\/\$/", "", $newkey);
     $this->s3->putObject(['Bucket' => $this->options['bucket'], 'Key' => $newkey, 'Body' => $content, 'ACL' => CannedAcl::PUBLIC_READ]);
     return true;
 }
Example #20
0
 /**
  * Adds an object to a bucket.
  *
  * @param string $bucket
  * @param string $key
  * @param string $content
  * @param array  $params
  *
  * @return mixed
  */
 public function putObject($bucket, $key, $content, array $params = [])
 {
     $params['Bucket'] = $bucket;
     $params['Key'] = $key;
     $params['Body'] = $content;
     return $this->instance->putObject($params);
 }
Example #21
0
 /**
  * @param $file
  * @param $name
  * @param $mime
  * @return string
  */
 protected function putFileOnAmazon($file, $name, $mime)
 {
     $arr = array('ACL' => 'public-read', 'Bucket' => $this->bucket, 'Key' => $name, 'Body' => is_resource($file) ? $file : file_get_contents($file), 'ValidateMD5' => false, 'ContentMD5' => false, 'ContentType' => $mime);
     /* @var \Guzzle\Service\Resource\Model $obj */
     $obj = $this->client->putObject($arr);
     return str_replace('https://', 'http://', $obj->get('ObjectURL'));
 }
Example #22
0
 /**
  * Write a string to a file
  *
  * @param  string  $path     file path
  * @param  string  $content  new file content
  * @return bool
  * @author Dmitry (dio) Levashov
  **/
 protected function _filePutContents($path, $content)
 {
     $newkey = $this->_normpath($path);
     $newkey = preg_replace("/\\/\$/", "", $newkey);
     $ext = strtolower(pathinfo($path, PATHINFO_EXTENSION));
     $this->s3->putObject(['Bucket' => $this->options['bucket'], 'Key' => $newkey, 'Body' => $content, 'ACL' => CannedAcl::PUBLIC_READ, 'ContentType' => self::$mimetypes[$ext]]);
     return true;
 }
 /**
  * Copies the local file $filePath to DFS under the same name, or a new name
  * if specified
  *
  * @param string      $srcFilePath Local file path to copy from
  * @param bool|string $dstFilePath
  *        Optional path to copy to. If not specified, $srcFilePath is used
  *
  * @return bool
  */
 public function copyToDFS($srcFilePath, $dstFilePath = false)
 {
     try {
         $this->s3client->putObject(array('Bucket' => $this->bucket, 'Key' => $dstFilePath ?: $srcFilePath, 'SourceFile' => $srcFilePath, 'ACL' => 'public-read'));
         return true;
     } catch (S3Exception $e) {
         eZDebug::writeError($e->getMessage(), __METHOD__);
         return false;
     }
 }
Example #24
0
 /**
  * @param $key string Name of the resource on S3
  * @param $localPath string Local path of the file you want to upload
  * @param bool $isPublic Set the resource to public
  * @return bool|\Guzzle\Service\Resource\Model
  */
 public function putFile($key, $localPath, $isPublic = false)
 {
     $options = array('Bucket' => $this->bucketName, 'Key' => $key, 'SourceFile' => $localPath);
     if ($isPublic) {
         $options['ACL'] = 'public-read';
     }
     try {
         return $this->s3Client->putObject($options);
     } catch (\Exception $e) {
         return false;
     }
 }
 /**
  * Write a string to a file
  *
  * @param  string  $path     file path
  * @param  string  $content  new file content
  * @return bool
  **/
 protected function _filePutContents($path, $content)
 {
     $oldSettings = $this->getFile($path);
     $settings = array("Bucket" => $this->bucket, "Key" => $this->pathToKey($path), "ACL" => $this->options['acl'], "Body" => $content);
     if ($oldSettings) {
         $settings['Metadata'] = $oldSettings['Metadata'];
         $settings['ContentType'] = $oldSettings['ContentType'];
         $settings['ACP'] = Aws\S3\Model\Acp::fromArray($this->s3->getObjectAcl(array('Bucket' => $this->bucket, 'Key' => $this->pathToKey($path)))->toArray());
         unset($settings['ACL']);
     }
     return $this->s3->putObject($settings);
 }
Example #26
0
 public function upload($target_name, $file, $content_type = 'text/json; charset=utf-8', $bucket = AWS_NETSUITE_SENDING_BUCKET)
 {
     $this->client = S3Client::factory(["key" => AWS_NETSUITE_INTEGRATION_KEY, "secret" => AWS_NETSUITE_INTEGRATION_SECRET]);
     $e = 0;
     try {
         $result = $this->client->putObject(array('Bucket' => $bucket, 'Key' => $target_name, 'SourceFile' => $file, 'ContentType' => $content_type, 'ACL' => 'private'));
         return true;
     } catch (Exception $e) {
         /* $this->out("There was an error uploading to S3"); */
     }
     return false;
 }
Example #27
0
 /**
  * @param string $container
  * @param string $name
  * @param string $localFileName
  * @param string $type
  *
  * @throws DfException
  */
 public function putBlobFromFile($container = '', $name = '', $localFileName = '', $type = '')
 {
     try {
         $this->checkConnection();
         $options = ['Bucket' => $container, 'Key' => $name, 'SourceFile' => $localFileName];
         if (!empty($type)) {
             $options['ContentType'] = $type;
         }
         $result = $this->blobConn->putObject($options);
     } catch (\Exception $ex) {
         throw new DfException('Failed to create blob "' . $name . '": ' . $ex->getMessage());
     }
 }
Example #28
0
 /**
  * Create Folder
  *
  * @param string $folder Folder
  *
  * @return bool
  * @throws
  */
 public function createFolder($folder)
 {
     $folder = trim($folder, "/") . "/";
     if ($folder === "/") {
         return true;
     }
     // Fail if this pseudo directory key already exists
     if ($this->exists($folder)) {
         return true;
     }
     $response = $this->clientS3->putObject(array('Bucket' => $this->bucket, 'Key' => $folder, 'ACL' => static::ACL_PUBLIC_READ, 'Body' => ""));
     return (bool) $response;
 }
Example #29
0
 /**
  * @param $file
  * @param $fileName
  * @param $path
  * @param $fileType
  * @return mixed
  */
 public function uploadThumbnail($file, $fileName, $path, $fileType)
 {
     $result['status'] = false;
     try {
         $uploadResult = $this->s3->putObject(['Body' => $file, 'Bucket' => $this->bucket, 'Key' => $path . '/' . $fileName, 'ContentType' => $fileType, 'ACL' => 'public-read', 'CacheControl' => '2592000']);
         $result['status'] = true;
         $result['objectUrl'] = $uploadResult['ObjectURL'];
         $result['uploadResult'] = $uploadResult;
     } catch (S3Exception $e) {
         echo $e . "\nThere was an error uploading the file.\n";
     }
     return $result;
 }
Example #30
0
 public function writeBack($tmpFile)
 {
     if (!isset(self::$tmpFiles[$tmpFile])) {
         return false;
     }
     try {
         $result = $this->connection->putObject(array('Bucket' => $this->bucket, 'Key' => $this->cleanKey(self::$tmpFiles[$tmpFile]), 'SourceFile' => $tmpFile, 'ContentType' => \OC_Helper::getMimeType($tmpFile), 'ContentLength' => filesize($tmpFile)));
         $this->testTimeout();
         unlink($tmpFile);
     } catch (S3Exception $e) {
         \OCP\Util::writeLog('files_external', $e->getMessage(), \OCP\Util::ERROR);
         return false;
     }
 }