1 <?php
  2 /**
  3  * Copyright 2012-2014 Rackspace US, Inc.
  4  *
  5  * Licensed under the Apache License, Version 2.0 (the "License");
  6  * you may not use this file except in compliance with the License.
  7  * You may obtain a copy of the License at
  8  *
  9  * http://www.apache.org/licenses/LICENSE-2.0
 10  *
 11  * Unless required by applicable law or agreed to in writing, software
 12  * distributed under the License is distributed on an "AS IS" BASIS,
 13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14  * See the License for the specific language governing permissions and
 15  * limitations under the License.
 16  */
 17 
 18 namespace OpenCloud\ObjectStore\Resource;
 19 
 20 use Guzzle\Http\EntityBody;
 21 use Guzzle\Http\Message\Response;
 22 use Guzzle\Http\Url;
 23 use OpenCloud\Common\Constants\Header as HeaderConst;
 24 use OpenCloud\Common\Exceptions;
 25 use OpenCloud\Common\Lang;
 26 use OpenCloud\ObjectStore\Constants\UrlType;
 27 
 28 /**
 29  * Objects are the basic storage entities in Cloud Files. They represent the
 30  * files and their optional metadata you upload to the system. When you upload
 31  * objects to Cloud Files, the data is stored as-is (without compression or
 32  * encryption) and consists of a location (container), the object's name, and
 33  * any metadata you assign consisting of key/value pairs.
 34  */
 35 class DataObject extends AbstractResource
 36 {
 37     const METADATA_LABEL = 'Object';
 38 
 39     /**
 40      * @var Container
 41      */
 42     private $container;
 43 
 44     /**
 45      * @var The file name of the object
 46      */
 47     protected $name;
 48 
 49     /**
 50      * @var EntityBody
 51      */
 52     protected $content;
 53 
 54     /**
 55      * @var bool Whether or not this object is a "pseudo-directory"
 56      * @link http://docs.openstack.org/trunk/openstack-object-storage/developer/content/pseudo-hierarchical-folders-directories.html
 57      */
 58     protected $directory = false;
 59 
 60     /**
 61      * @var string The object's content type
 62      */
 63     protected $contentType;
 64 
 65     /**
 66      * @var The size of this object.
 67      */
 68     protected $contentLength;
 69 
 70     /**
 71      * @var string Date of last modification.
 72      */
 73     protected $lastModified;
 74 
 75     /**
 76      * @var string Etag.
 77      */
 78     protected $etag;
 79 
 80     /**
 81      * Also need to set Container parent and handle pseudo-directories.
 82      * {@inheritDoc}
 83      *
 84      * @param Container $container
 85      * @param null      $data
 86      */
 87     public function __construct(Container $container, $data = null)
 88     {
 89         $this->setContainer($container);
 90 
 91         parent::__construct($container->getService());
 92 
 93         // For pseudo-directories, we need to ensure the name is set
 94         if (!empty($data->subdir)) {
 95             $this->setName($data->subdir)->setDirectory(true);
 96 
 97             return;
 98         }
 99 
100         $this->populate($data);
101     }
102 
103     /**
104      * A collection list of DataObjects contains a different data structure than the one returned for the
105      * "Retrieve Object" operation. So we need to stock the values differently.
106      * {@inheritDoc}
107      */
108     public function populate($info, $setObjects = true)
109     {
110         parent::populate($info, $setObjects);
111 
112         if (isset($info->bytes)) {
113             $this->setContentLength($info->bytes);
114         }
115         if (isset($info->last_modified)) {
116             $this->setLastModified($info->last_modified);
117         }
118         if (isset($info->content_type)) {
119             $this->setContentType($info->content_type);
120         }
121         if (isset($info->hash)) {
122             $this->setEtag($info->hash);
123         }
124     }
125 
126     /**
127      * Takes a response and stocks common values from both the body and the headers.
128      *
129      * @param Response $response
130      * @return $this
131      */
132     public function populateFromResponse(Response $response)
133     {
134         $this->content = $response->getBody();
135 
136         $headers = $response->getHeaders();
137 
138         return $this->setMetadata($headers, true)
139             ->setContentType((string) $headers[HeaderConst::CONTENT_TYPE])
140             ->setLastModified((string) $headers[HeaderConst::LAST_MODIFIED])
141             ->setContentLength((string) $headers[HeaderConst::CONTENT_LENGTH])
142             ->setEtag((string) $headers[HeaderConst::ETAG]);
143     }
144 
145     public function refresh()
146     {
147         $response = $this->getService()->getClient()
148             ->get($this->getUrl())
149             ->send();
150 
151         return $this->populateFromResponse($response);
152     }
153 
154     /**
155      * @param Container $container
156      * @return $this
157      */
158     public function setContainer(Container $container)
159     {
160         $this->container = $container;
161 
162         return $this;
163     }
164 
165     /**
166      * @return Container
167      */
168     public function getContainer()
169     {
170         return $this->container;
171     }
172 
173     /**
174      * @param $name string
175      * @return $this
176      */
177     public function setName($name)
178     {
179         $this->name = $name;
180 
181         return $this;
182     }
183 
184     /**
185      * @return string
186      */
187     public function getName()
188     {
189         return $this->name;
190     }
191 
192     /**
193      * @param $directory bool
194      * @return $this
195      */
196     public function setDirectory($directory)
197     {
198         $this->directory = $directory;
199 
200         return $this;
201     }
202 
203     /**
204      * @return bool
205      */
206     public function getDirectory()
207     {
208         return $this->directory;
209     }
210 
211     /**
212      * @return bool Is this data object a pseudo-directory?
213      */
214     public function isDirectory()
215     {
216         return (bool) $this->directory;
217     }
218 
219     /**
220      * @param  mixed $content
221      * @return $this
222      */
223     public function setContent($content)
224     {
225         $this->etag = null;
226         $this->contentType = null;
227         $this->content = EntityBody::factory($content);
228 
229         return $this;
230     }
231 
232     /**
233      * @return EntityBody
234      */
235     public function getContent()
236     {
237         return $this->content;
238     }
239 
240     /**
241      * @param  string $contentType
242      * @return $this
243      */
244     public function setContentType($contentType)
245     {
246         $this->contentType = $contentType;
247 
248         return $this;
249     }
250 
251     /**
252      * @return null|string
253      */
254     public function getContentType()
255     {
256         return $this->contentType ? : $this->content->getContentType();
257     }
258 
259     /**
260      * @param $contentType int
261      * @return $this
262      */
263     public function setContentLength($contentLength)
264     {
265         $this->contentLength = $contentLength;
266 
267         return $this;
268     }
269 
270     /**
271      * @return int
272      */
273     public function getContentLength()
274     {
275         return $this->contentLength !== null ? $this->contentLength : $this->content->getContentLength();
276     }
277 
278     /**
279      * @param $etag
280      * @return $this
281      */
282     public function setEtag($etag)
283     {
284         $this->etag = $etag;
285 
286         return $this;
287     }
288 
289     /**
290      * @return null|string
291      */
292     public function getEtag()
293     {
294         return $this->etag ? : $this->content->getContentMd5();
295     }
296 
297     public function setLastModified($lastModified)
298     {
299         $this->lastModified = $lastModified;
300 
301         return $this;
302     }
303 
304     public function getLastModified()
305     {
306         return $this->lastModified;
307     }
308 
309     public function primaryKeyField()
310     {
311         return 'name';
312     }
313 
314     public function getUrl($path = null, array $params = array())
315     {
316         if (!$this->name) {
317             throw new Exceptions\NoNameError(Lang::translate('Object has no name'));
318         }
319 
320         return $this->container->getUrl($this->name);
321     }
322 
323     public function update($params = array())
324     {
325         $metadata = is_array($this->metadata) ? $this->metadata : $this->metadata->toArray();
326         $metadata = self::stockHeaders($metadata);
327 
328         // merge specific properties with metadata
329         $metadata += array(
330             HeaderConst::CONTENT_TYPE   => $this->contentType,
331             HeaderConst::LAST_MODIFIED  => $this->lastModified,
332             HeaderConst::CONTENT_LENGTH => $this->contentLength,
333             HeaderConst::ETAG           => $this->etag
334         );
335 
336         return $this->container->uploadObject($this->name, $this->content, $metadata);
337     }
338 
339     /**
340      * @param string $destination Path (`container/object') of new object
341      * @return \Guzzle\Http\Message\Response
342      */
343     public function copy($destination)
344     {
345         return $this->getService()
346             ->getClient()
347             ->createRequest('COPY', $this->getUrl(), array(
348                 'Destination' => (string) $destination
349             ))
350             ->send();
351     }
352 
353     public function delete($params = array())
354     {
355         return $this->getService()->getClient()->delete($this->getUrl())->send();
356     }
357 
358     /**
359      * Get a temporary URL for this object.
360      *
361      * @link http://docs.rackspace.com/files/api/v1/cf-devguide/content/TempURL-d1a4450.html
362      *
363      * @param $expires Expiration time in seconds
364      * @param $method  What method can use this URL? (`GET' or `PUT')
365      * @return string
366      * @throws \OpenCloud\Common\Exceptions\InvalidArgumentError
367      * @throws \OpenCloud\Common\Exceptions\ObjectError
368      *
369      */
370     public function getTemporaryUrl($expires, $method)
371     {
372         $method = strtoupper($method);
373         $expiry = time() + (int) $expires;
374 
375         // check for proper method
376         if ($method != 'GET' && $method != 'PUT') {
377             throw new Exceptions\InvalidArgumentError(sprintf(
378                 'Bad method [%s] for TempUrl; only GET or PUT supported',
379                 $method
380             ));
381         }
382 
383         // @codeCoverageIgnoreStart
384         if (!($secret = $this->getService()->getAccount()->getTempUrlSecret())) {
385             throw new Exceptions\ObjectError('Cannot produce temporary URL without an account secret.');
386         }
387         // @codeCoverageIgnoreEnd
388 
389         $url = $this->getUrl();
390         $urlPath = urldecode($url->getPath());
391         $body = sprintf("%s\n%d\n%s", $method, $expiry, $urlPath);
392         $hash = hash_hmac('sha1', $body, $secret);
393 
394         return sprintf('%s?temp_url_sig=%s&temp_url_expires=%d', $url, $hash, $expiry);
395     }
396 
397     /**
398      * Remove this object from the CDN.
399      *
400      * @param null $email
401      * @return mixed
402      */
403     public function purge($email = null)
404     {
405         if (!$cdn = $this->getContainer()->getCdn()) {
406             return false;
407         }
408 
409         $url = clone $cdn->getUrl();
410         $url->addPath($this->name);
411 
412         $headers = ($email !== null) ? array('X-Purge-Email' => $email) : array();
413 
414         return $this->getService()
415             ->getClient()
416             ->delete($url, $headers)
417             ->send();
418     }
419 
420     /**
421      * @param string $type
422      * @return bool|Url
423      */
424     public function getPublicUrl($type = UrlType::CDN)
425     {
426         $cdn = $this->container->getCdn();
427 
428         switch ($type) {
429             case UrlType::CDN:
430                 $uri = $cdn->getCdnUri();
431                 break;
432             case UrlType::SSL:
433                 $uri = $cdn->getCdnSslUri();
434                 break;
435             case UrlType::STREAMING:
436                 $uri = $cdn->getCdnStreamingUri();
437                 break;
438             case UrlType::IOS_STREAMING:
439                 $uri = $cdn->getIosStreamingUri();
440                 break;
441         }
442 
443         return (isset($uri)) ? Url::factory($uri)->addPath($this->name) : false;
444     }
445 
446     protected static function headerIsValidMetadata($header)
447     {
448         $pattern = sprintf('#^%s-%s-Meta-#i', self::GLOBAL_METADATA_PREFIX, self::METADATA_LABEL);
449 
450         return preg_match($pattern, $header);
451     }
452 }
453 

API documentation generated by ApiGen