/**
* Adds new entry to the block list entries.
*
* @param string $blockId The block id.
* @param string $type The entry type, you can use BlobBlockType.
*
* @return none
*/
public function addEntry($blockId, $type)
{
Validate::isString($blockId, 'blockId');
Validate::isTrue(BlobBlockType::isValid($type), sprintf(Resources::INVALID_BTE_MSG, get_class(new BlobBlockType())));
$block = new Block();
$block->setBlockId($blockId);
$block->setType($type);
$this->_entries[] = $block;
}
/**
* Unserializes given serialized string to array.
*
* @param string $serialized The serialized object in string representation.
*
* @return array
*/
public function unserialize($serialized)
{
Validate::isString($serialized, 'serialized');
$json = json_decode($serialized);
if ($json && !is_array($json)) {
return get_object_vars($json);
} else {
return $json;
}
}
/**
* Creates BatchError object.
*
* @param MicrosoftAzure\Storage\Common\ServiceException $error The error object.
* @param array $headers The response headers.
*
* @return \MicrosoftAzure\Storage\Table\Models\BatchError
*/
public static function create($error, $headers)
{
Validate::isTrue($error instanceof ServiceException, Resources::INVALID_EXC_OBJ_MSG);
Validate::isArray($headers, 'headers');
$result = new BatchError();
$clean = array_change_key_case($headers);
$result->setError($error);
$contentId = Utilities::tryGetValue($clean, Resources::CONTENT_ID);
$result->setContentId(is_null($contentId) ? null : intval($contentId));
return $result;
}
/**
* Validate if string is date formatted
*
* @param string $value Value to validate
* @param string $name Name of parameter to insert in erro message
*
* @throws \InvalidArgumentException
*
* @return boolean
*/
public static function isDateString($value, $name)
{
Validate::isString($value, 'value');
try {
new \DateTime($value);
return true;
} catch (\Exception $e) {
throw new \InvalidArgumentException(sprintf(Resources::ERROR_INVALID_DATE_STRING, $name, $value));
}
}
/**
* Sets the include uncommittedBlobs flag.
*
* @param bool $includeUncommittedBlobs value.
*
* @return none.
*/
public function setIncludeUncommittedBlobs($includeUncommittedBlobs)
{
Validate::isBoolean($includeUncommittedBlobs);
$this->_includeUncommittedBlobs = $includeUncommittedBlobs;
}
/**
* Sets rangeEnd
*
* @param integer $rangeEnd range end value in bytes
*
* @return none
*/
public function setRangeEnd($rangeEnd)
{
Validate::isInteger($rangeEnd, 'rangeEnd');
$this->_rangeEnd = $rangeEnd;
}
/**
* Creates a snapshot of a blob.
*
* @param string $container The name of the container.
* @param string $blob The name of the blob.
* @param Models\CreateBlobSnapshotOptions $options The optional parameters.
*
* @return Models\CreateBlobSnapshotResult
*
* @see http://msdn.microsoft.com/en-us/library/windowsazure/ee691971.aspx
*/
public function createBlobSnapshot($container, $blob, $options = null)
{
Validate::isString($container, 'container');
Validate::isString($blob, 'blob');
Validate::notNullOrEmpty($blob, 'blob');
$method = Resources::HTTP_PUT;
$headers = array();
$postParams = array();
$queryParams = array();
$path = $this->_createPath($container, $blob);
$expectedStatusCode = Resources::STATUS_CREATED;
if (is_null($options)) {
$options = new CreateBlobSnapshotOptions();
}
$queryParams[Resources::QP_COMP] = 'snapshot';
$this->addOptionalQueryParam($queryParams, Resources::QP_TIMEOUT, $options->getTimeout());
$headers = $this->addOptionalAccessConditionHeader($headers, $options->getAccessCondition());
$headers = $this->addMetadataHeaders($headers, $options->getMetadata());
$this->addOptionalHeader($headers, Resources::X_MS_LEASE_ID, $options->getLeaseId());
$response = $this->send($method, $headers, $queryParams, $postParams, $path, $expectedStatusCode);
return CreateBlobSnapshotResult::create(HttpFormatter::formatHeaders($response->getHeaders()));
}
/**
* Initializes static members of the class.
*
* @return none
*/
protected static function init()
{
self::$_useDevelopmentStorageSetting = self::setting(Resources::USE_DEVELOPMENT_STORAGE_NAME, 'true');
self::$_developmentStorageProxyUriSetting = self::settingWithFunc(Resources::DEVELOPMENT_STORAGE_PROXY_URI_NAME, Validate::getIsValidUri());
self::$_defaultEndpointsProtocolSetting = self::setting(Resources::DEFAULT_ENDPOINTS_PROTOCOL_NAME, 'http', 'https');
self::$_accountNameSetting = self::setting(Resources::ACCOUNT_NAME_NAME);
self::$_accountKeySetting = self::settingWithFunc(Resources::ACCOUNT_KEY_NAME, function ($key) {
$isValidBase64String = base64_decode($key, true);
if ($isValidBase64String) {
return true;
} else {
throw new \RuntimeException(sprintf(Resources::INVALID_ACCOUNT_KEY_FORMAT, $key));
}
});
self::$_blobEndpointSetting = self::settingWithFunc(Resources::BLOB_ENDPOINT_NAME, Validate::getIsValidUri());
self::$_queueEndpointSetting = self::settingWithFunc(Resources::QUEUE_ENDPOINT_NAME, Validate::getIsValidUri());
self::$_tableEndpointSetting = self::settingWithFunc(Resources::TABLE_ENDPOINT_NAME, Validate::getIsValidUri());
self::$validSettingKeys[] = Resources::USE_DEVELOPMENT_STORAGE_NAME;
self::$validSettingKeys[] = Resources::DEVELOPMENT_STORAGE_PROXY_URI_NAME;
self::$validSettingKeys[] = Resources::DEFAULT_ENDPOINTS_PROTOCOL_NAME;
self::$validSettingKeys[] = Resources::ACCOUNT_NAME_NAME;
self::$validSettingKeys[] = Resources::ACCOUNT_KEY_NAME;
self::$validSettingKeys[] = Resources::BLOB_ENDPOINT_NAME;
self::$validSettingKeys[] = Resources::QUEUE_ENDPOINT_NAME;
self::$validSettingKeys[] = Resources::TABLE_ENDPOINT_NAME;
}
/**
* Adds deleteEntity operation.
*
* @param string $table The table name.
* @param string $partitionKey The entity partition key.
* @param string $rowKey The entity row key.
* @param string $etag The entity etag.
*
* @return none
*/
public function addDeleteEntity($table, $partitionKey, $rowKey, $etag = null)
{
Validate::isString($table, 'table');
Validate::isTrue(!is_null($partitionKey), Resources::NULL_TABLE_KEY_MSG);
Validate::isTrue(!is_null($rowKey), Resources::NULL_TABLE_KEY_MSG);
$operation = new BatchOperation();
$type = BatchOperationType::DELETE_ENTITY_OPERATION;
$operation->setType($type);
$operation->addParameter(BatchOperationParameterName::BP_TABLE, $table);
$operation->addParameter(BatchOperationParameterName::BP_ROW_KEY, $rowKey);
$operation->addParameter(BatchOperationParameterName::BP_ETAG, $etag);
$operation->addParameter(BatchOperationParameterName::BP_PARTITION_KEY, $partitionKey);
$this->addOperation($operation);
}
/**
* Adds or sets parameter for the operation.
*
* @param string $name The param name. Must be valid name.
* @param mix $value The param value.
*
* @return none
*/
public function addParameter($name, $value)
{
Validate::isTrue(BatchOperationParameterName::isValid($name), Resources::INVALID_BO_PN_MSG);
$this->_params[$name] = $value;
}
/**
* Sets blob etag.
*
* @param string $etag value.
*
* @return none.
*/
public function setETag($etag)
{
Validate::isString($etag, 'etag');
$this->_etag = $etag;
}
/**
* Sets blob contentLength.
*
* @param integer $contentLength value.
*
* @return none.
*/
public function setContentLength($contentLength)
{
Validate::isInteger($contentLength, 'contentLength');
$this->_contentLength = $contentLength;
}
/**
* Sets the include metadata flag.
*
* @param bool $includeMetadata value.
*
* @return none.
*/
public function setIncludeMetadata($includeMetadata)
{
Validate::isBoolean($includeMetadata);
$this->_includeMetadata = $includeMetadata;
}
/**
* Does batch of operations on the table service.
*
* @param Models\BatchOperations $batchOperations The operations to apply.
* @param Models\TableServiceOptions $options The optional parameters.
*
* @return Models\BatchResult
*/
public function batch($batchOperations, $options = null)
{
Validate::notNullOrEmpty($batchOperations, 'batchOperations');
$method = Resources::HTTP_POST;
$operations = $batchOperations->getOperations();
$contexts = $this->_createOperationsContexts($operations);
$mime = $this->_createBatchRequestBody($operations, $contexts);
$body = $mime['body'];
$headers = $mime['headers'];
$postParams = array();
$queryParams = array();
$statusCode = Resources::STATUS_ACCEPTED;
$path = '$batch';
if (is_null($options)) {
$options = new TableServiceOptions();
}
$this->addOptionalQueryParam($queryParams, Resources::QP_TIMEOUT, $options->getTimeout());
$response = $this->send($method, $headers, $queryParams, $postParams, $path, $statusCode, $body);
return BatchResult::create($response->getBody(), $operations, $contexts, $this->_atomSerializer, $this->_mimeSerializer);
}
/**
* Sets computeRangeMD5
*
* @param boolean $computeRangeMD5 value
*
* @return none
*/
public function setComputeRangeMD5($computeRangeMD5)
{
Validate::isBoolean($computeRangeMD5);
$this->_computeRangeMD5 = $computeRangeMD5;
}
/**
* Updates the visibility timeout of a message and/or the message contents.
*
* @param string $queueName The queue name.
* @param string $messageId The id of the message.
* @param string $popReceipt The valid pop receipt
* value returned from an earlier call to the Get Messages or Update Message
* operation.
* @param string $messageText The message contents.
* @param int $visibilityTimeoutInSeconds Specifies the new
* visibility timeout value, in seconds, relative to server time.
* The new value must be larger than or equal to 0, and cannot be larger
* than 7 days. The visibility timeout of a message cannot be set to a value
* later than the expiry time. A message can be updated until it has been
* deleted or has expired.
* @param QueueServiceOptions $options The optional
* parameters.
*
* @return MicrosoftAzure\Storage\Common\Models\UpdateMessageResult
*/
public function updateMessage($queueName, $messageId, $popReceipt, $messageText, $visibilityTimeoutInSeconds, $options = null)
{
Validate::isString($queueName, 'queueName');
Validate::notNullOrEmpty($queueName, 'queueName');
Validate::isString($messageId, 'messageId');
Validate::notNullOrEmpty($messageId, 'messageId');
Validate::isString($popReceipt, 'popReceipt');
Validate::notNullOrEmpty($popReceipt, 'popReceipt');
Validate::isString($messageText, 'messageText');
Validate::isInteger($visibilityTimeoutInSeconds, 'visibilityTimeoutInSeconds');
Validate::notNull($visibilityTimeoutInSeconds, 'visibilityTimeoutInSeconds');
$method = Resources::HTTP_PUT;
$headers = array();
$postParams = array();
$queryParams = array();
$path = $queueName . '/messages' . '/' . $messageId;
$body = Resources::EMPTY_STRING;
$statusCode = Resources::STATUS_NO_CONTENT;
if (is_null($options)) {
$options = new QueueServiceOptions();
}
$this->addOptionalQueryParam($queryParams, Resources::QP_VISIBILITY_TIMEOUT, $visibilityTimeoutInSeconds);
$this->addOptionalQueryParam($queryParams, Resources::QP_TIMEOUT, $options->getTimeout());
$this->addOptionalQueryParam($queryParams, Resources::QP_POPRECEIPT, $popReceipt);
if (!empty($messageText)) {
$this->addOptionalHeader($headers, Resources::CONTENT_TYPE, Resources::URL_ENCODED_CONTENT_TYPE);
$message = new QueueMessage();
$message->setMessageText($messageText);
$body = $message->toXml($this->dataSerializer);
}
$response = $this->send($method, $headers, $queryParams, $postParams, $path, $statusCode, $body);
$responseHeaders = HttpFormatter::formatHeaders($response->getHeaders());
$popReceipt = Utilities::tryGetValue($responseHeaders, Resources::X_MS_POPRECEIPT);
$timeNextVisible = Utilities::tryGetValue($responseHeaders, Resources::X_MS_TIME_NEXT_VISIBLE);
$date = Utilities::rfc1123ToDateTime($timeNextVisible);
$result = new UpdateMessageResult();
$result->setPopReceipt($popReceipt);
$result->setTimeNextVisible($date);
return $result;
}
/**
* Sets header type
*
* @param string $headerType can be one of Resources
*
* @return none.
*/
public function setHeader($headerType)
{
$valid = AccessCondition::isValid($headerType);
Validate::isTrue($valid, Resources::INVALID_HT_MSG);
$this->_header = $headerType;
}
/**
* Serialize an object with specified root element name.
*
* @param object $targetObject The target object.
* @param string $rootName The name of the root element.
*
* @return string
*/
public static function objectSerialize($targetObject, $rootName)
{
Validate::notNull($targetObject, 'targetObject');
Validate::isString($rootName, 'rootName');
$xmlWriter = new \XmlWriter();
$xmlWriter->openMemory();
$xmlWriter->setIndent(true);
$reflectionClass = new \ReflectionClass($targetObject);
$methodArray = $reflectionClass->getMethods();
$attributes = self::_getInstanceAttributes($targetObject, $methodArray);
$xmlWriter->startElement($rootName);
if (!is_null($attributes)) {
foreach (array_keys($attributes) as $attributeKey) {
$xmlWriter->writeAttribute($attributeKey, $attributes[$attributeKey]);
}
}
foreach ($methodArray as $method) {
if (strpos($method->name, 'get') === 0 && $method->isPublic() && $method->name != 'getAttributes') {
$variableName = substr($method->name, 3);
$variableValue = $method->invoke($targetObject);
if (!empty($variableValue)) {
if (gettype($variableValue) === 'object') {
$xmlWriter->writeRaw(XmlSerializer::objectSerialize($variableValue, $variableName));
} else {
$xmlWriter->writeElement($variableName, $variableValue);
}
}
}
}
$xmlWriter->endElement();
return $xmlWriter->outputMemory(true);
}
/**
* Sets blob sequenceNumber.
*
* @param int $sequenceNumber value.
*
* @return none.
*/
public function setSequenceNumber($sequenceNumber)
{
Validate::isInteger($sequenceNumber, 'sequenceNumber');
$this->_sequenceNumber = $sequenceNumber;
}
/**
* Validates the provided metadata array.
*
* @param mix $metadata The metadata array.
*
* @return none
*/
public function validateMetadata($metadata)
{
if (!is_null($metadata)) {
Validate::isArray($metadata, 'metadata');
} else {
$metadata = array();
}
foreach ($metadata as $key => $value) {
Validate::isString($key, 'metadata key');
Validate::isString($value, 'metadata value');
}
}
/**
* Sets popReceipt field.
*
* @param string $popReceipt The pop receipt of the queue message.
*
* @return none.
*/
public function setPopReceipt($popReceipt)
{
Validate::isString($popReceipt, 'popReceipt');
$this->_popReceipt = $popReceipt;
}
/**
* Adds new signed modifier
*
* @param string $id a unique id for this modifier
* @param \DateTime $start The time at which the Shared Access Signature
* becomes valid. If omitted, start time for this call is assumed to be
* the time when the Blob service receives the request.
* @param \DateTime $expiry The time at which the Shared Access Signature
* becomes invalid. This field may be omitted if it has been specified as
* part of a container-level access policy.
* @param string $permission The permissions associated with the Shared
* Access Signature. The user is restricted to operations allowed by the
* permissions. Valid permissions values are read (r), write (w), delete (d) and
* list (l).
*
* @return none.
*
* @see http://msdn.microsoft.com/en-us/library/windowsazure/hh508996.aspx
*/
public function addSignedIdentifier($id, $start, $expiry, $permission)
{
Validate::isString($id, 'id');
Validate::isDate($start);
Validate::isDate($expiry);
Validate::isString($permission, 'permission');
$accessPolicy = new AccessPolicy();
$accessPolicy->setStart($start);
$accessPolicy->setExpiry($expiry);
$accessPolicy->setPermission($permission);
$signedIdentifier = new SignedIdentifier();
$signedIdentifier->setId($id);
$signedIdentifier->setAccessPolicy($accessPolicy);
$this->_signedIdentifiers[] = $signedIdentifier;
}
/**
* Sets entity property.
*
* @param string $name The property name.
* @param Property $property The property object.
*
* @return none
*/
public function setProperty($name, $property)
{
Validate::isTrue($property instanceof Property, Resources::INVALID_PROP_MSG);
$this->_properties[$name] = $property;
}
/**
* Specifies whether data in the container may be accessed publicly and the level
* of access. Possible values include:
* 1) container: Specifies full public read access for container and blob data.
* Clients can enumerate blobs within the container via anonymous request, but
* cannot enumerate containers within the storage account.
* 2) blob: Specifies public read access for blobs. Blob data within this
* container can be read via anonymous request, but container data is not
* available. Clients cannot enumerate blobs within the container via
* anonymous request.
* If this value is not specified in the request, container data is private to
* the account owner.
*
* @param string $publicAccess access modifier for the container
*
* @return none.
*/
public function setPublicAccess($publicAccess)
{
Validate::isString($publicAccess, 'publicAccess');
$this->_publicAccess = $publicAccess;
}
/**
* Adds optional header.
*
* Doesn't add the value if it satisfies empty().
*
* @param array &$headers The HTTP header parameters.
* @param string $key The HTTP header name.
* @param string $value The HTTP header value.
*
* @return none
*/
protected function addOptionalHeader(&$headers, $key, $value)
{
Validate::isArray($headers, 'headers');
Validate::isString($key, 'key');
Validate::isString($value, 'value');
if (!is_null($value) && Resources::EMPTY_STRING !== $value) {
$headers[$key] = $value;
}
}
/**
* Converts the type to string if it's empty and validates the type.
*
* @param string $type The Edm type
*
* @return string
*/
public static function processType($type)
{
$type = empty($type) ? self::STRING : $type;
Validate::isTrue(self::isValid($type), Resources::INVALID_EDM_MSG);
return $type;
}
/**
* @covers MicrosoftAzure\Storage\Common\Internal\Validate::isDateString
*/
public function testIsDateStringNotValid()
{
// Setup
$this->setExpectedException('\\InvalidArgumentException');
$value = 'not a date';
// Test
$result = Validate::isDateString($value, 'name');
// Assert
}
/**
* Sets expiry.
*
* @param \DateTime $expiry value.
*
* @return none.
*/
public function setExpiry($expiry)
{
Validate::isDate($expiry);
$this->_expiry = $expiry;
}
/**
* Unregisters a connection string source.
*
* @param string $name The source name.
*
* @return callable
*/
public static function unregisterSource($name)
{
Validate::isString($name, 'name');
Validate::notNullOrEmpty($name, 'name');
self::_init();
$sourceCallback = Utilities::tryGetValue(self::$_sources, $name);
if (!is_null($sourceCallback)) {
unset(self::$_sources[$name]);
}
return $sourceCallback;
}
/**
* Sets blob deleteSnaphotsOnly.
*
* @param string $deleteSnaphotsOnly value.
*
* @return boolean.
*/
public function setDeleteSnaphotsOnly($deleteSnaphotsOnly)
{
Validate::isBoolean($deleteSnaphotsOnly);
$this->_deleteSnaphotsOnly = $deleteSnaphotsOnly;
}
