Обновление клиента (apps, 3rdparty, install)

3rdparty/microsoft/azure-storage-common/src/Common/Internal/ACLBase.php

@@ -0,0 +1,260 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Models
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+use MicrosoftAzure\Storage\Common\Models\AccessPolicy;
+use MicrosoftAzure\Storage\Common\Models\SignedIdentifier;
+use MicrosoftAzure\Storage\Common\Internal\Serialization\XmlSerializer;
+
+/**
+ * Provide base class for service ACLs.
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Models
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+abstract class ACLBase
+{
+    private $signedIdentifiers = array();
+    private $resourceType = '';
+
+    /**
+     * Create an AccessPolicy object by resource type.
+     *
+     * @return AccessPolicy
+     */
+    abstract protected static function createAccessPolicy();
+
+    /**
+     * Validate if the resource type for the class.
+     *
+     * @param  string $resourceType the resource type to be validated.
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @internal
+     *
+     * @return void
+     */
+    abstract protected static function validateResourceType($resourceType);
+
+    /**
+     * Converts signed identifiers to array representation for XML serialization
+     *
+     * @internal
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        $array = array();
+
+        foreach ($this->getSignedIdentifiers() as $value) {
+            $array[] = $value->toArray();
+        }
+
+        return $array;
+    }
+
+    /**
+     * Converts this signed identifiers to XML representation.
+     *
+     * @param  XmlSerializer $xmlSerializer The XML serializer.
+     *
+     * @internal
+     *
+     * @return string
+     */
+    public function toXml(XmlSerializer $serializer)
+    {
+        $properties = array(
+            XmlSerializer::DEFAULT_TAG => Resources::XTAG_SIGNED_IDENTIFIER,
+            XmlSerializer::ROOT_NAME   => Resources::XTAG_SIGNED_IDENTIFIERS
+        );
+
+        return $serializer->serialize($this->toArray(), $properties);
+    }
+
+    /**
+     * Construct the signed identifiers from a given parsed XML in array
+     * representation.
+     *
+     * @param array|null  $parsed The parsed XML into array representation.
+     *
+     * @internal
+     *
+     * @return void
+     */
+    public function fromXmlArray(array $parsed = null)
+    {
+        $this->setSignedIdentifiers(array());
+
+        // Initialize signed identifiers.
+        if (!empty($parsed) &&
+                is_array($parsed[Resources::XTAG_SIGNED_IDENTIFIER])
+        ) {
+            $entries = $parsed[Resources::XTAG_SIGNED_IDENTIFIER];
+            $temp    = Utilities::getArray($entries);
+
+            foreach ($temp as $value) {
+                $accessPolicy = $value[Resources::XTAG_ACCESS_POLICY];
+                $startString  = urldecode(
+                    $accessPolicy[Resources::XTAG_SIGNED_START]
+                );
+                $expiryString = urldecode(
+                    $accessPolicy[Resources::XTAG_SIGNED_EXPIRY]
+                );
+                $start        = Utilities::convertToDateTime($startString);
+                $expiry       = Utilities::convertToDateTime($expiryString);
+                $permission   = $accessPolicy[Resources::XTAG_SIGNED_PERMISSION];
+                $id           = $value[Resources::XTAG_SIGNED_ID];
+                $this->addSignedIdentifier($id, $start, $expiry, $permission);
+            }
+        }
+    }
+
+    /**
+     * Gets the type of resource this ACL relate to.
+     *
+     * @internal
+     *
+     * @return string
+     */
+    protected function getResourceType()
+    {
+        return $this->resourceType;
+    }
+
+    /**
+     * Set the type of resource this ACL relate to.
+     *
+     * @internal
+     *
+     * @return void
+     */
+    protected function setResourceType($resourceType)
+    {
+        static::validateResourceType($resourceType);
+        $this->resourceType = $resourceType;
+    }
+
+    /**
+     * Add a signed identifier to the ACL.
+     *
+     * @param string    $id          A unique id for this signed identifier.
+     * @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 service receives the
+     *                               request.
+     * @param \DateTime $expiry      The time at which the Shared Access
+     *                               Signature becomes invalid.
+     * @param string    $permissions The permissions associated with the Shared
+     *                               Access Signature. The user is restricted to
+     *                               operations allowed by the permissions.
+     *
+     * @return void
+     *
+     * @see https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/establishing-a-stored-access-policy
+     */
+    public function addSignedIdentifier(
+        $id,
+        \DateTime $start,
+        \DateTime $expiry,
+        $permissions
+    ) {
+        Validate::canCastAsString($id, 'id');
+        if ($start != null) {
+            Validate::isDate($start);
+        }
+        Validate::isDate($expiry);
+        Validate::canCastAsString($permissions, 'permissions');
+
+        $accessPolicy = static::createAccessPolicy();
+        $accessPolicy->setStart($start);
+        $accessPolicy->setExpiry($expiry);
+        $accessPolicy->setPermission($permissions);
+
+        $signedIdentifier = new SignedIdentifier();
+        $signedIdentifier->setId($id);
+        $signedIdentifier->setAccessPolicy($accessPolicy);
+
+        // Remove the signed identifier with the same ID.
+        $this->removeSignedIdentifier($id);
+
+        // There can be no more than 5 signed identifiers at the same time.
+        Validate::isTrue(
+            count($this->getSignedIdentifiers()) < 5,
+            Resources::ERROR_TOO_MANY_SIGNED_IDENTIFIERS
+        );
+
+        $this->signedIdentifiers[] = $signedIdentifier;
+    }
+
+    /**
+     * Remove the signed identifier with given ID.
+     *
+     * @param  string $id The ID of the signed identifier to be removed.
+     *
+     * @return boolean
+     */
+    public function removeSignedIdentifier($id)
+    {
+        Validate::canCastAsString($id, 'id');
+        //var_dump($this->signedIdentifiers);
+        for ($i = 0; $i < count($this->signedIdentifiers); ++$i) {
+            if ($this->signedIdentifiers[$i]->getId() == $id) {
+                array_splice($this->signedIdentifiers, $i, 1);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Gets signed identifiers.
+     *
+     * @return array
+     */
+    public function getSignedIdentifiers()
+    {
+        return $this->signedIdentifiers;
+    }
+
+    public function setSignedIdentifiers(array $signedIdentifiers)
+    {
+        // There can be no more than 5 signed identifiers at the same time.
+        Validate::isTrue(
+            count($signedIdentifiers) <= 5,
+            Resources::ERROR_TOO_MANY_SIGNED_IDENTIFIERS
+        );
+        $this->signedIdentifiers = $signedIdentifiers;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Authentication/IAuthScheme.php

@@ -0,0 +1,52 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Authentication
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Authentication;
+
+use GuzzleHttp\Psr7\Request;
+
+/**
+ * Interface for azure authentication schemes.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Authentication
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+interface IAuthScheme
+{
+    /**
+     * Signs a request.
+     *
+     * @param  \GuzzleHttp\Psr7\Request $request HTTP request object.
+     *
+     * @abstract
+     *
+     * @return \GuzzleHttp\Psr7\Request
+     */
+    public function signRequest(Request $request);
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Authentication/SharedAccessSignatureAuthScheme.php

@@ -0,0 +1,96 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Authentication
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Authentication;
+
+use GuzzleHttp\Psr7\Request;
+use MicrosoftAzure\Storage\Common\Internal\Resources;
+
+/**
+ * Base class for azure authentication schemes.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Authentication
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class SharedAccessSignatureAuthScheme implements IAuthScheme
+{
+    /**
+     * The sas token
+     */
+    protected $sasToken;
+
+    /**
+     * Constructor.
+     *
+     * @param string $sasToken shared access signature token.
+     *
+     */
+    public function __construct($sasToken)
+    {
+        // Remove '?' in front of the SAS token if existing
+        $this->sasToken = str_replace('?', '', $sasToken, $i);
+
+        if ($i > 1) {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    Resources::INVALID_SAS_TOKEN,
+                    $sasToken
+                )
+            );
+        }
+    }
+
+    /**
+     * Adds authentication header to the request headers.
+     *
+     * @param  \GuzzleHttp\Psr7\Request $request HTTP request object.
+     *
+     * @abstract
+     *
+     * @return \GuzzleHttp\Psr7\Request
+     */
+    public function signRequest(Request $request)
+    {
+        // initial URI
+        $uri = $request->getUri();
+
+        // new query values from SAS token
+        $queryValues = explode('&', $this->sasToken);
+
+        // append SAS token query values to existing URI
+        foreach ($queryValues as $queryField) {
+            list($key, $value) = explode('=', $queryField);
+
+            $uri = \GuzzleHttp\Psr7\Uri::withQueryValue($uri, $key, $value);
+        }
+
+        // replace URI
+        return $request->withUri($uri, true);
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Authentication/SharedKeyAuthScheme.php

@@ -0,0 +1,317 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Authentication
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Authentication;
+
+use GuzzleHttp\Psr7\Query;
+use GuzzleHttp\Psr7\Request;
+use MicrosoftAzure\Storage\Common\Internal\Http\HttpFormatter;
+use MicrosoftAzure\Storage\Common\Internal\Resources;
+use MicrosoftAzure\Storage\Common\Internal\Utilities;
+
+/**
+ * Provides shared key authentication scheme for blob and queue. For more info
+ * check: http://msdn.microsoft.com/en-us/library/windowsazure/dd179428.aspx
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Authentication
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class SharedKeyAuthScheme implements IAuthScheme
+{
+    /**
+     * The account name
+     */
+    protected $accountName;
+
+    /**
+     * The account key
+     */
+    protected $accountKey;
+
+    /**
+     * The included headers
+     */
+    protected $includedHeaders;
+
+    /**
+     * Constructor.
+     *
+     * @param string $accountName storage account name.
+     * @param string $accountKey  storage account primary or secondary key.
+     *
+     * @return SharedKeyAuthScheme
+     */
+    public function __construct($accountName, $accountKey)
+    {
+        $this->accountKey  = $accountKey;
+        $this->accountName = $accountName;
+
+        $this->includedHeaders   = array();
+        $this->includedHeaders[] = Resources::CONTENT_ENCODING;
+        $this->includedHeaders[] = Resources::CONTENT_LANGUAGE;
+        $this->includedHeaders[] = Resources::CONTENT_LENGTH;
+        $this->includedHeaders[] = Resources::CONTENT_MD5;
+        $this->includedHeaders[] = Resources::CONTENT_TYPE;
+        $this->includedHeaders[] = Resources::DATE;
+        $this->includedHeaders[] = Resources::IF_MODIFIED_SINCE;
+        $this->includedHeaders[] = Resources::IF_MATCH;
+        $this->includedHeaders[] = Resources::IF_NONE_MATCH;
+        $this->includedHeaders[] = Resources::IF_UNMODIFIED_SINCE;
+        $this->includedHeaders[] = Resources::RANGE;
+    }
+
+    /**
+     * Computes the authorization signature for blob and queue shared key.
+     *
+     * @param array  $headers     request headers.
+     * @param string $url         reuqest url.
+     * @param array  $queryParams query variables.
+     * @param string $httpMethod  request http method.
+     *
+     * @see Blob and Queue Services (Shared Key Authentication) at
+     *      http://msdn.microsoft.com/en-us/library/windowsazure/dd179428.aspx
+     *
+     * @return string
+     */
+    protected function computeSignature(
+        array $headers,
+        $url,
+        array $queryParams,
+        $httpMethod
+    ) {
+        $canonicalizedHeaders = $this->computeCanonicalizedHeaders($headers);
+
+        $canonicalizedResource = $this->computeCanonicalizedResource(
+            $url,
+            $queryParams
+        );
+
+        $stringToSign   = array();
+        $stringToSign[] = strtoupper($httpMethod);
+
+        foreach ($this->includedHeaders as $header) {
+            $stringToSign[] = Utilities::tryGetValueInsensitive($header, $headers);
+        }
+
+        if (count($canonicalizedHeaders) > 0) {
+            $stringToSign[] = implode("\n", $canonicalizedHeaders);
+        }
+
+        $stringToSign[] = $canonicalizedResource;
+        $stringToSign   = implode("\n", $stringToSign);
+
+        return $stringToSign;
+    }
+
+    /**
+     * Returns authorization header to be included in the request.
+     *
+     * @param array  $headers     request headers.
+     * @param string $url         reuqest url.
+     * @param array  $queryParams query variables.
+     * @param string $httpMethod  request http method.
+     *
+     * @see Specifying the Authorization Header section at
+     *      http://msdn.microsoft.com/en-us/library/windowsazure/dd179428.aspx
+     *
+     * @return string
+     */
+    public function getAuthorizationHeader(
+        array $headers,
+        $url,
+        array $queryParams,
+        $httpMethod
+    ) {
+        $signature = $this->computeSignature(
+            $headers,
+            $url,
+            $queryParams,
+            $httpMethod
+        );
+
+        return 'SharedKey ' . $this->accountName . ':' . base64_encode(
+            hash_hmac('sha256', $signature, base64_decode($this->accountKey), true)
+        );
+    }
+
+    /**
+     * Computes canonicalized headers for headers array.
+     *
+     * @param array $headers request headers.
+     *
+     * @see Constructing the Canonicalized Headers String section at
+     *      http://msdn.microsoft.com/en-us/library/windowsazure/dd179428.aspx
+     *
+     * @return array
+     */
+    protected function computeCanonicalizedHeaders($headers)
+    {
+        $canonicalizedHeaders = array();
+        $normalizedHeaders    = array();
+        $validPrefix          =  Resources::X_MS_HEADER_PREFIX;
+
+        if (is_null($normalizedHeaders)) {
+            return $canonicalizedHeaders;
+        }
+
+        foreach ($headers as $header => $value) {
+            // Convert header to lower case.
+            $header = strtolower($header);
+
+            // Retrieve all headers for the resource that begin with x-ms-,
+            // including the x-ms-date header.
+            if (Utilities::startsWith($header, $validPrefix)) {
+                // Unfold the string by replacing any breaking white space
+                // (meaning what splits the headers, which is \r\n) with a single
+                // space.
+                $value = str_replace("\r\n", ' ', $value);
+
+                // Trim any white space around the colon in the header.
+                $value  = ltrim($value);
+                $header = rtrim($header);
+
+                $normalizedHeaders[$header] = $value;
+            }
+        }
+
+        // Sort the headers lexicographically by header name, in ascending order.
+        // Note that each header may appear only once in the string.
+        ksort($normalizedHeaders);
+
+        foreach ($normalizedHeaders as $key => $value) {
+            $canonicalizedHeaders[] = $key . ':' . $value;
+        }
+
+        return $canonicalizedHeaders;
+    }
+
+    /**
+     * Computes canonicalized resources from URL using Table formar
+     *
+     * @param string $url         request url.
+     * @param array  $queryParams request query variables.
+     *
+     * @see Constructing the Canonicalized Resource String section at
+     *      http://msdn.microsoft.com/en-us/library/windowsazure/dd179428.aspx
+     *
+     * @return string
+     */
+    protected function computeCanonicalizedResourceForTable($url, $queryParams)
+    {
+        $queryParams = array_change_key_case($queryParams);
+
+        // 1. Beginning with an empty string (""), append a forward slash (/),
+        //    followed by the name of the account that owns the accessed resource.
+        $canonicalizedResource = '/' . $this->accountName;
+
+        // 2. Append the resource's encoded URI path, without any query parameters.
+        $canonicalizedResource .= parse_url($url, PHP_URL_PATH);
+
+        // 3. The query string should include the question mark and the comp
+        //    parameter (for example, ?comp=metadata). No other parameters should
+        //    be included on the query string.
+        if (array_key_exists(Resources::QP_COMP, $queryParams)) {
+            $canonicalizedResource .= '?' . Resources::QP_COMP . '=';
+            $canonicalizedResource .= $queryParams[Resources::QP_COMP];
+        }
+
+        return $canonicalizedResource;
+    }
+
+    /**
+     * Computes canonicalized resources from URL.
+     *
+     * @param string $url         request url.
+     * @param array  $queryParams request query variables.
+     *
+     * @see Constructing the Canonicalized Resource String section at
+     *      http://msdn.microsoft.com/en-us/library/windowsazure/dd179428.aspx
+     *
+     * @return string
+     */
+    protected function computeCanonicalizedResource($url, $queryParams)
+    {
+        $queryParams = array_change_key_case($queryParams);
+
+        // 1. Beginning with an empty string (""), append a forward slash (/),
+        //    followed by the name of the account that owns the accessed resource.
+        $canonicalizedResource = '/' . $this->accountName;
+
+        // 2. Append the resource's encoded URI path, without any query parameters.
+        $canonicalizedResource .= parse_url($url, PHP_URL_PATH);
+
+        // 3. Retrieve all query parameters on the resource URI, including the comp
+        //    parameter if it exists.
+        // 4. Sort the query parameters lexicographically by parameter name, in
+        //    ascending order.
+        if (count($queryParams) > 0) {
+            ksort($queryParams);
+        }
+
+        // 5. Convert all parameter names to lowercase.
+        // 6. URL-decode each query parameter name and value.
+        // 7. Append each query parameter name and value to the string in the
+        //    following format:
+        //      parameter-name:parameter-value
+        // 9. Group query parameters
+        // 10. Append a new line character (\n) after each name-value pair.
+        foreach ($queryParams as $key => $value) {
+            // $value must already be ordered lexicographically
+            // See: ServiceRestProxy::groupQueryValues
+            $canonicalizedResource .= "\n" . $key . ':' . $value;
+        }
+
+        return $canonicalizedResource;
+    }
+
+    /**
+     * Adds authentication header to the request headers.
+     *
+     * @param  \GuzzleHttp\Psr7\Request $request HTTP request object.
+     *
+     * @abstract
+     *
+     * @return \GuzzleHttp\Psr7\Request
+     */
+    public function signRequest(Request $request)
+    {
+        $requestHeaders = HttpFormatter::formatHeaders($request->getHeaders());
+
+        $signedKey = $this->getAuthorizationHeader(
+            $requestHeaders,
+            $request->getUri(),
+            Query::parse(
+                $request->getUri()->getQuery()
+            ),
+            $request->getMethod()
+        );
+
+        return $request->withHeader(Resources::AUTHENTICATION, $signedKey);
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Authentication/TokenAuthScheme.php

@@ -0,0 +1,73 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Authentication
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2019 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Authentication;
+
+use GuzzleHttp\Psr7\Request;
+use MicrosoftAzure\Storage\Common\Internal\Resources;
+use MicrosoftAzure\Storage\Common\Internal\Validate;
+
+/**
+ * Azure authentication scheme for token credential.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Authentication
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2019 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class TokenAuthScheme implements IAuthScheme
+{
+    /**
+     * The authentication token
+     */
+    protected $tokenRef;
+
+    /**
+     * Constructor.
+     *
+     * @param string $token the token used for AAD authentication.
+     */
+    public function __construct(&$token)
+    {
+        $this->tokenRef =& $token;
+    }
+
+    /**
+     * Adds authentication header to the request headers.
+     *
+     * @param \GuzzleHttp\Psr7\Request $request HTTP request object.
+     *
+     * @abstract
+     *
+     * @return \GuzzleHttp\Psr7\Request
+     */
+    public function signRequest(Request $request)
+    {
+        $bearerToken = "Bearer ". $this->tokenRef;
+        return $request->withHeader(Resources::AUTHENTICATION, $bearerToken);
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/ConnectionStringParser.php

@@ -0,0 +1,335 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+/**
+ * Helper methods for parsing connection strings. The rules for formatting connection
+ * strings are defined here:
+ * www.connectionstrings.com/articles/show/important-rules-for-connection-strings
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class ConnectionStringParser
+{
+    const EXPECT_KEY        = 'ExpectKey';
+    const EXPECT_ASSIGNMENT = 'ExpectAssignment';
+    const EXPECT_VALUE      = 'ExpectValue';
+    const EXPECT_SEPARATOR  = 'ExpectSeparator';
+
+    private $_argumentName;
+    private $_value;
+    private $_pos;
+    private $_state;
+
+    /**
+     * Parses the connection string into a collection of key/value pairs.
+     *
+     * @param string $argumentName     Name of the argument to be used in error
+     * messages.
+     * @param string $connectionString Connection string.
+     *
+     * @return array
+     */
+    public static function parseConnectionString($argumentName, $connectionString)
+    {
+        Validate::canCastAsString($argumentName, 'argumentName');
+        Validate::notNullOrEmpty($argumentName, 'argumentName');
+        Validate::canCastAsString($connectionString, 'connectionString');
+        Validate::notNullOrEmpty($connectionString, 'connectionString');
+
+        $parser = new ConnectionStringParser($argumentName, $connectionString);
+        return $parser->_parse();
+    }
+
+    /**
+     * Initializes the object.
+     *
+     * @param string $argumentName Name of the argument to be used in error
+     * messages.
+     * @param string $value        Connection string.
+     */
+    private function __construct($argumentName, $value)
+    {
+        $this->_argumentName = $argumentName;
+        $this->_value        = $value;
+        $this->_pos          = 0;
+        $this->_state        = ConnectionStringParser::EXPECT_KEY;
+    }
+
+    /**
+     * Parses the connection string.
+     *
+     * @return array
+     *
+     * @throws \RuntimeException
+     */
+    private function _parse()
+    {
+        $key                    = null;
+        $value                  = null;
+        $connectionStringValues = array();
+
+        while (true) {
+            $this->_skipWhiteSpaces();
+
+            if ($this->_pos == strlen($this->_value)
+                && $this->_state != ConnectionStringParser::EXPECT_VALUE
+            ) {
+                // Not stopping after the end has been reached and a value is
+                // expected results in creating an empty value, which we expect.
+                break;
+            }
+
+            switch ($this->_state) {
+                case ConnectionStringParser::EXPECT_KEY:
+                    $key          = $this->_extractKey();
+                    $this->_state = ConnectionStringParser::EXPECT_ASSIGNMENT;
+                    break;
+
+                case ConnectionStringParser::EXPECT_ASSIGNMENT:
+                    $this->_skipOperator('=');
+                    $this->_state = ConnectionStringParser::EXPECT_VALUE;
+                    break;
+
+                case ConnectionStringParser::EXPECT_VALUE:
+                    $value                        = $this->_extractValue();
+                    $this->_state                 =
+                    ConnectionStringParser::EXPECT_SEPARATOR;
+                    $connectionStringValues[$key] = $value;
+                    $key                          = null;
+                    $value                        = null;
+                    break;
+
+                default:
+                    $this->_skipOperator(';');
+                    $this->_state = ConnectionStringParser::EXPECT_KEY;
+                    break;
+            }
+        }
+
+        // Must end parsing in the valid state (expected key or separator)
+        if ($this->_state == ConnectionStringParser::EXPECT_ASSIGNMENT) {
+            throw $this->_createException(
+                $this->_pos,
+                Resources::MISSING_CONNECTION_STRING_CHAR,
+                '='
+            );
+        }
+
+        return $connectionStringValues;
+    }
+
+    /**
+     *Generates an invalid connection string exception with the detailed error
+     * message.
+     *
+     * @param integer $position    The position of the error.
+     * @param string  $errorString The short error formatting string.
+     *
+     * @return \RuntimeException
+     */
+    private function _createException($position, $errorString)
+    {
+        $arguments = func_get_args();
+
+        // Remove first and second arguments (position and error string)
+        unset($arguments[0], $arguments[1]);
+
+        // Create a short error message.
+        $errorString = vsprintf($errorString, $arguments);
+
+        // Add position.
+        $errorString = sprintf(
+            Resources::ERROR_PARSING_STRING,
+            $errorString,
+            $position
+        );
+
+        // Create final error message.
+        $errorString = sprintf(
+            Resources::INVALID_CONNECTION_STRING,
+            $this->_argumentName,
+            $errorString
+        );
+
+        return new \RuntimeException($errorString);
+    }
+
+    /**
+     * Skips whitespaces at the current position.
+     *
+     * @return void
+     */
+    private function _skipWhiteSpaces()
+    {
+        while ($this->_pos < strlen($this->_value)
+              &&  ctype_space($this->_value[$this->_pos])
+        ) {
+            $this->_pos++;
+        }
+    }
+
+    /**
+     * Extracts the key's value.
+     *
+     * @return string
+     */
+    private function _extractValue()
+    {
+        $value = Resources::EMPTY_STRING;
+
+        if ($this->_pos < strlen($this->_value)) {
+            $ch = $this->_value[$this->_pos];
+
+            if ($ch == '"' || $ch == '\'') {
+                // Value is contained between double quotes or skipped single quotes.
+                $this->_pos++;
+                $value = $this->_extractString($ch);
+            } else {
+                $firstPos = $this->_pos;
+                $isFound  = false;
+
+                while ($this->_pos < strlen($this->_value) && !$isFound) {
+                    $ch = $this->_value[$this->_pos];
+
+                    if ($ch == ';') {
+                        $isFound = true;
+                    } else {
+                        $this->_pos++;
+                    }
+                }
+
+                $value = rtrim(
+                    substr($this->_value, $firstPos, $this->_pos - $firstPos)
+                );
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * Extracts key at the current position.
+     *
+     * @return string
+     */
+    private function _extractKey()
+    {
+        $key      = null;
+        $firstPos = $this->_pos;
+        $ch       = $this->_value[$this->_pos];
+
+        if ($ch == '"' || $ch == '\'') {
+            $this->_pos++;
+            $key = $this->_extractString($ch);
+        } elseif ($ch == ';' || $ch == '=') {
+            // Key name was expected.
+            throw $this->_createException(
+                $firstPos,
+                Resources::ERROR_CONNECTION_STRING_MISSING_KEY
+            );
+        } else {
+            while ($this->_pos < strlen($this->_value)) {
+                $ch = $this->_value[$this->_pos];
+
+                // At this point we've read the key, break.
+                if ($ch == '=') {
+                    break;
+                }
+
+                $this->_pos++;
+            }
+            $key = rtrim(substr($this->_value, $firstPos, $this->_pos - $firstPos));
+        }
+
+        if (strlen($key) == 0) {
+            // Empty key name.
+            throw $this->_createException(
+                $firstPos,
+                Resources::ERROR_CONNECTION_STRING_EMPTY_KEY
+            );
+        }
+
+        return $key;
+    }
+
+    /**
+     * Extracts the string until the given quotation mark.
+     *
+     * @param string $quote The quotation mark terminating the string.
+     *
+     * @return string
+     */
+    private function _extractString($quote)
+    {
+        $firstPos = $this->_pos;
+
+        while ($this->_pos < strlen($this->_value)
+              &&  $this->_value[$this->_pos] != $quote
+        ) {
+            $this->_pos++;
+        }
+
+        if ($this->_pos == strlen($this->_value)) {
+            // Runaway string.
+            throw $this->_createException(
+                $this->_pos,
+                Resources::ERROR_CONNECTION_STRING_MISSING_CHARACTER,
+                $quote
+            );
+        }
+
+        return substr($this->_value, $firstPos, $this->_pos++ - $firstPos);
+    }
+
+    /**
+     * Skips specified operator.
+     *
+     * @param string $operatorChar The operator character.
+     *
+     * @return void
+     *
+     * @throws \RuntimeException
+     */
+    private function _skipOperator($operatorChar)
+    {
+        if ($this->_value[$this->_pos] != $operatorChar) {
+            // Character was expected.
+            throw $this->_createException(
+                $this->_pos,
+                Resources::MISSING_CONNECTION_STRING_CHAR,
+                $operatorChar
+            );
+        }
+
+        $this->_pos++;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/ConnectionStringSource.php

@@ -0,0 +1,83 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+/**
+ * Holder for default connection string sources used in CloudConfigurationManager.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class ConnectionStringSource
+{
+    private static $_defaultSources;
+    private static $_isInitialized;
+    const ENVIRONMENT_SOURCE = 'environment_source';
+
+    /**
+     * Initializes the default sources.
+     *
+     * @return void
+     */
+    private static function _init()
+    {
+        if (!self::$_isInitialized) {
+            self::$_defaultSources = array(
+                self::ENVIRONMENT_SOURCE => array(__CLASS__, 'environmentSource')
+            );
+            self::$_isInitialized  = true;
+        }
+    }
+
+    /**
+     * Gets a connection string value from the system environment.
+     *
+     * @param string $key The connection string name.
+     *
+     * @return string
+     */
+    public static function environmentSource($key)
+    {
+        Validate::canCastAsString($key, 'key');
+
+        return getenv($key);
+    }
+
+    /**
+     * Gets list of default sources.
+     *
+     * @return array
+     */
+    public static function getDefaultSources()
+    {
+        self::_init();
+        return self::$_defaultSources;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Http/HttpCallContext.php

@@ -0,0 +1,432 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Http
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Http;
+
+use MicrosoftAzure\Storage\Common\Internal\Utilities;
+use MicrosoftAzure\Storage\Common\Internal\Resources;
+use MicrosoftAzure\Storage\Common\Internal\Validate;
+use MicrosoftAzure\Storage\Common\Models\ServiceOptions;
+
+/**
+ * Holds basic elements for making HTTP call.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Http
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class HttpCallContext
+{
+    private $_method;
+    private $_headers;
+    private $_queryParams;
+    private $_postParameters;
+    private $_uri;
+    private $_path;
+    private $_statusCodes;
+    private $_body;
+    private $_serviceOptions;
+
+    /**
+     * Default constructor.
+     */
+    public function __construct()
+    {
+        $this->_method         = null;
+        $this->_body           = null;
+        $this->_path           = null;
+        $this->_uri            = null;
+        $this->_queryParams    = array();
+        $this->_postParameters = array();
+        $this->_statusCodes    = array();
+        $this->_headers        = array();
+        $this->_serviceOptions = new ServiceOptions();
+    }
+
+    /**
+     * Gets method.
+     *
+     * @return string
+     */
+    public function getMethod()
+    {
+        return $this->_method;
+    }
+
+    /**
+     * Sets method.
+     *
+     * @param string $method The method value.
+     *
+     * @return void
+     */
+    public function setMethod($method)
+    {
+        Validate::canCastAsString($method, 'method');
+
+        $this->_method = $method;
+    }
+
+    /**
+     * Gets headers.
+     *
+     * @return array
+     */
+    public function getHeaders()
+    {
+        return $this->_headers;
+    }
+
+    /**
+     * Sets headers.
+     *
+     * Ignores the header if its value is empty.
+     *
+     * @param array $headers The headers value.
+     *
+     * @return void
+     */
+    public function setHeaders(array $headers)
+    {
+        $this->_headers = array();
+        foreach ($headers as $key => $value) {
+            $this->addHeader($key, $value);
+        }
+    }
+
+    /**
+     * Gets queryParams.
+     *
+     * @return array
+     */
+    public function getQueryParameters()
+    {
+        return $this->_queryParams;
+    }
+
+    /**
+     * Sets queryParams.
+     *
+     * Ignores the query variable if its value is empty.
+     *
+     * @param array $queryParams The queryParams value.
+     *
+     * @return void
+     */
+    public function setQueryParameters(array $queryParams)
+    {
+        $this->_queryParams = array();
+        foreach ($queryParams as $key => $value) {
+            $this->addQueryParameter($key, $value);
+        }
+    }
+
+    /**
+     * Gets uri.
+     *
+     * @return string
+     */
+    public function getUri()
+    {
+        return $this->_uri;
+    }
+
+    /**
+     * Sets uri.
+     *
+     * @param string $uri The uri value.
+     *
+     * @return void
+     */
+    public function setUri($uri)
+    {
+        Validate::canCastAsString($uri, 'uri');
+
+        $this->_uri = $uri;
+    }
+
+    /**
+     * Gets path.
+     *
+     * @return string
+     */
+    public function getPath()
+    {
+        return $this->_path;
+    }
+
+    /**
+     * Sets path.
+     *
+     * @param string $path The path value.
+     *
+     * @return void
+     */
+    public function setPath($path)
+    {
+        Validate::canCastAsString($path, 'path');
+
+        $this->_path = $path;
+    }
+
+    /**
+     * Gets statusCodes.
+     *
+     * @return array
+     */
+    public function getStatusCodes()
+    {
+        return $this->_statusCodes;
+    }
+
+    /**
+     * Sets statusCodes.
+     *
+     * @param array $statusCodes The statusCodes value.
+     *
+     * @return void
+     */
+    public function setStatusCodes(array $statusCodes)
+    {
+        $this->_statusCodes = array();
+        foreach ($statusCodes as $value) {
+            $this->addStatusCode($value);
+        }
+    }
+
+    /**
+     * Gets body.
+     *
+     * @return string
+     */
+    public function getBody()
+    {
+        return $this->_body;
+    }
+
+    /**
+     * Sets body.
+     *
+     * @param string $body The body value.
+     *
+     * @return void
+     */
+    public function setBody($body)
+    {
+        Validate::canCastAsString($body, 'body');
+
+        $this->_body = $body;
+    }
+
+    /**
+     * Adds or sets header pair.
+     *
+     * @param string $name  The HTTP header name.
+     * @param string $value The HTTP header value.
+     *
+     * @return void
+     */
+    public function addHeader($name, $value)
+    {
+        Validate::canCastAsString($name, 'name');
+        Validate::canCastAsString($value, 'value');
+
+        $this->_headers[$name] = $value;
+    }
+
+    /**
+     * Adds or sets header pair.
+     *
+     * Ignores header if it's value satisfies empty().
+     *
+     * @param string $name  The HTTP header name.
+     * @param string $value The HTTP header value.
+     *
+     * @return void
+     */
+    public function addOptionalHeader($name, $value)
+    {
+        Validate::canCastAsString($name, 'name');
+        Validate::canCastAsString($value, 'value');
+
+        if (!empty($value)) {
+            $this->_headers[$name] = $value;
+        }
+    }
+
+    /**
+     * Removes header from the HTTP request headers.
+     *
+     * @param string $name The HTTP header name.
+     *
+     * @return void
+     */
+    public function removeHeader($name)
+    {
+        Validate::canCastAsString($name, 'name');
+        Validate::notNullOrEmpty($name, 'name');
+
+        unset($this->_headers[$name]);
+    }
+
+    /**
+     * Adds or sets query parameter pair.
+     *
+     * @param string $name  The URI query parameter name.
+     * @param string $value The URI query parameter value.
+     *
+     * @return void
+     */
+    public function addQueryParameter($name, $value)
+    {
+        Validate::canCastAsString($name, 'name');
+        Validate::canCastAsString($value, 'value');
+
+        $this->_queryParams[$name] = $value;
+    }
+
+    /**
+     * Gets HTTP POST parameters.
+     *
+     * @return array
+     */
+    public function getPostParameters()
+    {
+        return $this->_postParameters;
+    }
+
+    /**
+     * Sets HTTP POST parameters.
+     *
+     * @param array $postParameters The HTTP POST parameters.
+     *
+     * @return void
+     */
+    public function setPostParameters(array $postParameters)
+    {
+        Validate::isArray($postParameters, 'postParameters');
+        $this->_postParameters = $postParameters;
+    }
+
+    /**
+     * Adds or sets query parameter pair.
+     *
+     * Ignores query parameter if it's value satisfies empty().
+     *
+     * @param string $name  The URI query parameter name.
+     * @param string $value The URI query parameter value.
+     *
+     * @return void
+     */
+    public function addOptionalQueryParameter($name, $value)
+    {
+        Validate::canCastAsString($name, 'name');
+        Validate::canCastAsString($value, 'value');
+
+        if (!empty($value)) {
+            $this->_queryParams[$name] = $value;
+        }
+    }
+
+    /**
+     * Adds status code to the expected status codes.
+     *
+     * @param integer $statusCode The expected status code.
+     *
+     * @return void
+     */
+    public function addStatusCode($statusCode)
+    {
+        Validate::isInteger($statusCode, 'statusCode');
+
+        $this->_statusCodes[] = $statusCode;
+    }
+
+    /**
+     * Gets header value.
+     *
+     * @param string $name The header name.
+     *
+     * @return mixed
+     */
+    public function getHeader($name)
+    {
+        return Utilities::tryGetValue($this->_headers, $name);
+    }
+
+    /**
+     * Gets the saved service options
+     *
+     * @return ServiceOptions
+     */
+    public function getServiceOptions()
+    {
+        if ($this->_serviceOptions == null) {
+            $this->_serviceOptions = new ServiceOptions();
+        }
+        return $this->_serviceOptions;
+    }
+
+    /**
+     * Sets the service options
+     *
+     * @param ServiceOptions $serviceOptions the service options to be set.
+     *
+     * @return void
+     */
+    public function setServiceOptions(ServiceOptions $serviceOptions)
+    {
+        $this->_serviceOptions = $serviceOptions;
+    }
+
+    /**
+     * Converts the context object to string.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        $headers = Resources::EMPTY_STRING;
+        $uri     = $this->_uri;
+
+        if ($uri === null) {
+            $uri = '/';
+        } elseif ($uri[strlen($uri)-1] != '/') {
+            $uri = $uri.'/';
+        }
+
+        foreach ($this->_headers as $key => $value) {
+            $headers .= "$key: $value\n";
+        }
+
+        $str  = "$this->_method $uri$this->_path HTTP/1.1\n$headers\n";
+        $str .= "$this->_body";
+
+        return $str;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Http/HttpFormatter.php

@@ -0,0 +1,59 @@
+<?php
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Http
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Http;
+
+/**
+ * Helper class to format the http headers
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Http
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class HttpFormatter
+{
+    /**
+     * Convert a http headers array into an uniformed format for further process
+     *
+     * @param array $headers headers for format
+     *
+     * @return array
+     */
+    public static function formatHeaders(array $headers)
+    {
+        $result = array();
+        foreach ($headers as $key => $value) {
+            if (is_array($value) && count($value) == 1) {
+                $result[strtolower($key)] = $value[0];
+            } else {
+                $result[strtolower($key)] = $value;
+            }
+        }
+
+        return $result;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/MetadataTrait.php

@@ -0,0 +1,142 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+/**
+ * Trait implementing common logic for metadata, last-modified and etag. The
+ * code is shared for multiple REST APIs.
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+trait MetadataTrait
+{
+    private $lastModified;
+    private $etag;
+    private $metadata;
+
+    /**
+     * Any operation that modifies the share or its properties or metadata
+     * updates the last modified time. Operations on files do not affect the
+     * last modified time of the share.
+     *
+     * @return \DateTime.
+     */
+    public function getLastModified()
+    {
+        return $this->lastModified;
+    }
+
+    /**
+     * Sets share lastModified.
+     *
+     * @param \DateTime $lastModified value.
+     *
+     * @return void
+     */
+    protected function setLastModified(\DateTime $lastModified)
+    {
+        $this->lastModified = $lastModified;
+    }
+
+    /**
+     * The entity tag for the share. If the request version is 2011-08-18 or
+     * newer, the ETag value will be in quotes.
+     *
+     * @return string
+     */
+    public function getETag()
+    {
+        return $this->etag;
+    }
+
+    /**
+     * Sets share etag.
+     *
+     * @param string $etag value.
+     *
+     * @return void
+     */
+    protected function setETag($etag)
+    {
+        $this->etag = $etag;
+    }
+
+    /**
+     * Gets user defined metadata.
+     *
+     * @return array
+     */
+    public function getMetadata()
+    {
+        return $this->metadata;
+    }
+
+    /**
+     * Sets user defined metadata. This metadata should be added without the
+     * header prefix (x-ms-meta-*).
+     *
+     * @param array $metadata user defined metadata object in array form.
+     *
+     * @return void
+     */
+    protected function setMetadata(array $metadata)
+    {
+        $this->metadata = $metadata;
+    }
+
+    /**
+     * Create an instance using the response headers from the API call.
+     *
+     * @param  array  $responseHeaders The array contains all the response headers
+     *
+     * @internal
+     *
+     * @return GetShareMetadataResult
+     */
+    public static function createMetadataResult(array $responseHeaders)
+    {
+        $result   = new static();
+        $metadata = Utilities::getMetadataArray($responseHeaders);
+        $date     = Utilities::tryGetValueInsensitive(
+            Resources::LAST_MODIFIED,
+            $responseHeaders
+        );
+        $date     = Utilities::rfc1123ToDateTime($date);
+        $result->setETag(Utilities::tryGetValueInsensitive(
+            Resources::ETAG,
+            $responseHeaders
+        ));
+        $result->setMetadata($metadata);
+        $result->setLastModified($date);
+
+        return $result;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Middlewares/CommonRequestMiddleware.php

@@ -0,0 +1,132 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Middlewares;
+
+use MicrosoftAzure\Storage\Common\Middlewares\MiddlewareBase;
+use MicrosoftAzure\Storage\Common\Internal\Authentication\IAuthScheme;
+use MicrosoftAzure\Storage\Common\Internal\Resources;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * CommonRequestMiddleware is the middleware used to add the necessary headers
+ * and to sign the request with provided authentication scheme. This middleware
+ * is by default applied to each of the request.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class CommonRequestMiddleware extends MiddlewareBase
+{
+    private $authenticationScheme;
+    private $headers;
+    private $msVersion;
+    private $userAgent;
+
+    /**
+     * Creates CommonRequestMiddleware with the passed scheme and headers to
+     * be added.
+     *
+     * @param IAuthScheme $authenticationScheme The authentication scheme.
+     * @param string      $storageAPIVersion    Azure Storage Service API version,
+     *                                          like '2016-05-31'.
+     * @param string      $serviceSDKVersion    Like '1.0.1' or '1.2.0'.
+     * @param array       $headers              The headers to be added.
+     */
+    public function __construct(
+        IAuthScheme $authenticationScheme = null,
+        $storageAPIVersion,
+        $serviceSDKVersion,
+        array $headers = array()
+    ) {
+        $this->authenticationScheme = $authenticationScheme;
+        $this->msVersion            = $storageAPIVersion;
+        $this->userAgent            = self::getUserAgent($serviceSDKVersion);
+        $this->headers              = $headers;
+    }
+
+    /**
+     * Add the provided headers, the date, then sign the request using the
+     * authentication scheme, and return it.
+     *
+     * @param  RequestInterface $request un-signed request.
+     *
+     * @return RequestInterface
+     */
+    protected function onRequest(RequestInterface $request)
+    {
+        $result = $request;
+
+        //Adding headers.
+        foreach ($this->headers as $key => $value) {
+            $headers = $result->getHeaders();
+            if (!array_key_exists($key, $headers)) {
+                $result = $result->withHeader($key, $value);
+            }
+        }
+
+        //rewriting version and user-agent.
+        $result = $result->withHeader(
+            Resources::X_MS_VERSION,
+            $this->msVersion
+        );
+        $result = $result->withHeader(
+            Resources::USER_AGENT,
+            $this->userAgent
+        );
+
+        //Adding date.
+        $date = gmdate(Resources::AZURE_DATE_FORMAT, time());
+        $result = $result->withHeader(Resources::DATE, $date);
+
+        //Adding client request-ID if not specified by the user.
+        if (!$result->hasHeader(Resources::X_MS_CLIENT_REQUEST_ID)) {
+            $result = $result->withHeader(Resources::X_MS_CLIENT_REQUEST_ID, \uniqid());
+        }
+        //Sign the request if authentication scheme is not null.
+        $request = $this->authenticationScheme == null ?
+            $request : $this->authenticationScheme->signRequest($result);
+        return $request;
+    }
+
+    /**
+     * Gets the user agent string used in request header.
+     *
+     * @param $serviceSDKVersion
+     *
+     * @return string
+     */
+    private static function getUserAgent($serviceSDKVersion)
+    {
+        // e.g. User-Agent: Azure-Storage/1.0.1-1.1.1 (PHP 5.5.32)/WINNT
+        return 'Azure-Storage/' . $serviceSDKVersion . '-' .
+            Resources::COMMON_SDK_VERSION .
+            ' (PHP ' . PHP_VERSION . ')' . '/' . php_uname("s");
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Resources.php

@@ -0,0 +1,422 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+/**
+ * Project resources.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class Resources
+{
+    // @codingStandardsIgnoreStart
+
+    // Connection strings
+    const USE_DEVELOPMENT_STORAGE_NAME = 'UseDevelopmentStorage';
+    const DEVELOPMENT_STORAGE_PROXY_URI_NAME = 'DevelopmentStorageProxyUri';
+    const DEFAULT_ENDPOINTS_PROTOCOL_NAME = 'DefaultEndpointsProtocol';
+    const ACCOUNT_NAME_NAME = 'AccountName';
+    const ACCOUNT_KEY_NAME = 'AccountKey';
+    const SAS_TOKEN_NAME = 'SharedAccessSignature';
+    const BLOB_ENDPOINT_NAME = 'BlobEndpoint';
+    const QUEUE_ENDPOINT_NAME = 'QueueEndpoint';
+    const TABLE_ENDPOINT_NAME = 'TableEndpoint';
+    const FILE_ENDPOINT_NAME = 'FileEndpoint';
+    const SHARED_ACCESS_SIGNATURE_NAME = 'SharedAccessSignature';
+    const ENDPOINT_SUFFIX_NAME = 'EndpointSuffix';
+    const DEFAULT_ENDPOINT_SUFFIX = 'core.windows.net';
+    const DEV_STORE_NAME = 'devstoreaccount1';
+    const DEV_STORE_KEY = 'Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==';
+    const BLOB_BASE_DNS_NAME = 'blob.core.windows.net';
+    const BLOB_DNS_PREFIX = 'blob.';
+    const QUEUE_BASE_DNS_NAME = 'queue.core.windows.net';
+    const QUEUE_DNS_PREFIX = 'queue.';
+    const TABLE_BASE_DNS_NAME = 'table.core.windows.net';
+    const TABLE_DNS_PREFIX = 'table.';
+    const FILE_BASE_DNS_NAME = 'file.core.windows.net';
+    const FILE_DNS_PREFIX = 'file.';
+    const DEV_STORE_CONNECTION_STRING = 'BlobEndpoint=127.0.0.1:10000;QueueEndpoint=127.0.0.1:10001;TableEndpoint=127.0.0.1:10002;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==';
+    const SUBSCRIPTION_ID_NAME = 'SubscriptionID';
+    const CERTIFICATE_PATH_NAME = 'CertificatePath';
+    const SECONDARY_STRING = '-secondary';
+    const PRIMARY_STRING = '-primary';
+
+    // Messages
+    const INVALID_FUNCTION_NAME = 'The class %s does not have a function named %s.';
+    const INVALID_TYPE_MSG = 'The provided variable should be of type: ';
+    const INVALID_META_MSG = 'Metadata cannot contain newline characters.';
+    const AZURE_ERROR_MSG = "Fail:\nCode: %s\nValue: %s\ndetails (if any): %s.";
+    const NOT_IMPLEMENTED_MSG = 'This method is not implemented.';
+    const NULL_OR_EMPTY_MSG = "'%s' can't be NULL or empty.";
+    const NULL_MSG = "'%s' can't be NULL.";
+    const INVALID_URL_MSG = 'Provided URL is invalid.';
+    const INVALID_HT_MSG = 'The header type provided is invalid.';
+    const INVALID_VERSION_MSG = 'Server does not support any known protocol versions.';
+    const INVALID_EXC_OBJ_MSG = 'Exception object type should be ServiceException.';
+    const INVALID_PARAM_MSG = "The provided variable '%s' should be of type '%s'";
+    const INVALID_VALUE_MSG = "The provided variable '%s' has unexpected value. Reason: '%s'";
+    const INVALID_STRING_LENGTH = "The provided variable '%s' should be of %s characters long";
+    const INVALID_SVC_PROP_MSG = 'The provided service properties is invalid.';
+    const UNKNOWN_SRILZER_MSG = 'The provided serializer type is unknown';
+    const INVALID_CREATE_SERVICE_OPTIONS_MSG = 'Must provide valid location or affinity group.';
+    const INVALID_UPDATE_SERVICE_OPTIONS_MSG = 'Must provide either description or label.';
+    const INVALID_CONFIG_MSG = 'Config object must be of type Configuration';
+    const INVALID_CONFIG_HOSTNAME = "The provided hostname '%s' is invalid.";
+    const INVALID_CONFIG_URI = "The provided URI '%s' is invalid. It has to pass the check 'filter_var(<user_uri>, FILTER_VALIDATE_URL)'.";
+    const INVALID_CONFIG_VALUE = "The provided config value '%s' does not belong to the valid values subset:\n%s";
+    const INVALID_ACCOUNT_KEY_FORMAT = "The provided account key '%s' is not a valid base64 string. It has to pass the check 'base64_decode(<user_account_key>, true)'.";
+    const MISSING_CONNECTION_STRING_SETTINGS = "The provided connection string '%s' does not have complete configuration settings.";
+    const INVALID_CONNECTION_STRING_SETTING_KEY = "The setting key '%s' is not found in the expected configuration setting keys:\n%s";
+    const INVALID_CERTIFICATE_PATH = "The provided certificate path '%s' is invalid.";
+    const INSTANCE_TYPE_VALIDATION_MSG = 'The type of %s is %s but is expected to be %s.';
+    const INVALID_MESSAGE_OBJECT_TO_SERIALIZE = 'The given object does not have required methods, so it could not be serialized.';
+    const MISSING_CONNECTION_STRING_CHAR = "Missing %s character";
+    const ERROR_PARSING_STRING = "'%s' at position %d.";
+    const INVALID_CONNECTION_STRING = "Argument '%s' is not a valid connection string: '%s'";
+    const ERROR_CONNECTION_STRING_MISSING_KEY = 'Missing key name';
+    const ERROR_CONNECTION_STRING_EMPTY_KEY = 'Empty key name';
+    const ERROR_CONNECTION_STRING_MISSING_CHARACTER = "Missing %s character";
+    const ERROR_EMPTY_SETTINGS = 'No keys were found in the connection string';
+    const MISSING_LOCK_LOCATION_MSG = 'The lock location of the brokered message is missing.';
+    const INVALID_SAS_TOKEN = 'The shared access signatures (SAS) provided is not valid \'%s\'';
+    const INVALID_SLOT = "The provided deployment slot '%s' is not valid. Only 'staging' and 'production' are accepted.";
+    const INVALID_DEPLOYMENT_LOCATOR_MSG = 'A slot or deployment name must be provided.';
+    const INVALID_CHANGE_MODE_MSG = "The change mode must be 'Auto' or 'Manual'. Use Mode class constants for that purpose.";
+    const INVALID_DEPLOYMENT_STATUS_MSG = "The change mode must be 'Running' or 'Suspended'. Use DeploymentStatus class constants for that purpose.";
+    const ERROR_OAUTH_GET_ACCESS_TOKEN = 'Unable to get oauth access token for endpoint \'%s\', account name \'%s\'';
+    const ERROR_OAUTH_SERVICE_MISSING = 'OAuth service missing for account name \'%s\'';
+    const ERROR_METHOD_NOT_FOUND = 'Method \'%s\' not found in object class \'%s\'';
+    const ERROR_INVALID_DATE_STRING = 'Parameter \'%s\' is not a date formatted string \'%s\'';
+    const ERROR_FILE_COULD_NOT_BE_OPENED = 'Error: file with given path could not be opened or created.';
+    const INVALID_PARAM_GENERAL = 'The provided parameter \'%s\' is invalid';
+    const INVALID_NEGATIVE_PARAM = 'The provided parameter \'%s\' should be positive number.';
+    const SIGNED_SERVICE_INVALID_VALIDATION_MSG = 'The signed service should only be a combination of the letters b(lob) q(ueue) t(able) or f(ile).';
+    const SIGNED_RESOURCE_TYPE_INVALID_VALIDATION_MSG = 'The signed resource type should only be a combination of the letters s(ervice) c(container) or o(bject).';
+    const STRING_NOT_WITH_GIVEN_COMBINATION = 'The string should only be a combination of the letters %s.';
+    const SIGNED_PROTOCOL_INVALID_VALIDATION_MSG = 'The signed protocol is invalid: possible values are https or https,http.';
+    const ERROR_RESOURCE_TYPE_NOT_SUPPORTED = 'The given resource type cannot be recognized or is not supported.';
+    const ERROR_TOO_MANY_SIGNED_IDENTIFIERS = 'There can be at most 5 signed identifiers at the same time.';
+    const INVALID_PERMISSION_PROVIDED = 'Invalid permission provided, the permission of resource type \'%s\' can only be of \'%s\'';
+    const INVALID_RESOURCE_TYPE = 'Provided resource type is invalid.';
+    const ERROR_KEY_NOT_EXIST = "The key '%s' does not exist in the given array.";
+    const RESOURCE_RANGE_LENGTH_MUST_SET = "The start and end/length of the range must be set.";
+    const INVALID_ACCEPT_CONTENT_TYPE = "The given accept content type is not valid.";
+    const ERROR_CANNOT_PARSE_XML = "Cannot parse XML, reasons: %s";
+    const INVALID_SCHEME = 'HTTP scheme can only be string \'http\' or \'https\'.';
+    const AAD_TOKEN_MUST_START_WITH_BEARER = 'AAD token is invalid, please make sure that it has format \'Bearer ################\'';
+
+    // HTTP Headers
+    const X_MS_HEADER_PREFIX                 = 'x-ms-';
+    const X_MS_META_HEADER_PREFIX            = 'x-ms-meta-';
+    const X_MS_VERSION                       = 'x-ms-version';
+    const X_MS_DATE                          = 'x-ms-date';
+    const X_MS_COPY_ACTION                   = 'x-ms-copy-action';
+    const X_MS_COPY_ID                       = 'x-ms-copy-id';
+    const X_MS_COPY_COMPLETION_TIME          = 'x-ms-copy-completion-time';
+    const X_MS_COPY_STATUS                   = 'x-ms-copy-status';
+    const X_MS_COPY_STATUS_DESCRIPTION       = 'x-ms-copy-status-description';
+    const X_MS_COPY_SOURCE                   = 'x-ms-copy-source';
+    const X_MS_COPY_PROGRESS                 = 'x-ms-copy-progress';
+    const X_MS_RANGE                         = 'x-ms-range';
+    const X_MS_RANGE_GET_CONTENT_MD5         = 'x-ms-range-get-content-md5';
+    const X_MS_DELETE_SNAPSHOTS              = 'x-ms-delete-snapshots';
+    const X_MS_SNAPSHOT                      = 'x-ms-snapshot';
+    const X_MS_SOURCE_IF_MODIFIED_SINCE      = 'x-ms-source-if-modified-since';
+    const X_MS_SOURCE_IF_UNMODIFIED_SINCE    = 'x-ms-source-if-unmodified-since';
+    const X_MS_SOURCE_IF_MATCH               = 'x-ms-source-if-match';
+    const X_MS_SOURCE_IF_NONE_MATCH          = 'x-ms-source-if-none-match';
+    const X_MS_SOURCE_LEASE_ID               = 'x-ms-source-lease-id';
+    const X_MS_CONTINUATION_NEXTTABLENAME    = 'x-ms-continuation-nexttablename';
+    const X_MS_CONTINUATION_NEXTPARTITIONKEY = 'x-ms-continuation-nextpartitionkey';
+    const X_MS_CONTINUATION_NEXTROWKEY       = 'x-ms-continuation-nextrowkey';
+    const X_MS_REQUEST_ID                    = 'x-ms-request-id';
+    const X_MS_CLIENT_REQUEST_ID             = 'x-ms-client-request-id';
+    const X_MS_CONTINUATION_LOCATION_MODE    = 'x-ms-continuation-location-mode';
+    const X_MS_TYPE                          = 'x-ms-type';
+    const X_MS_CONTENT_LENGTH                = 'x-ms-content-length';
+    const X_MS_CACHE_CONTROL                 = 'x-ms-cache-control';
+    const X_MS_CONTENT_TYPE                  = 'x-ms-content-type';
+    const X_MS_CONTENT_MD5                   = 'x-ms-content-md5';
+    const X_MS_CONTENT_ENCODING              = 'x-ms-content-encoding';
+    const X_MS_CONTENT_LANGUAGE              = 'x-ms-content-language';
+    const X_MS_CONTENT_DISPOSITION           = 'x-ms-content-disposition';
+    const X_MS_WRITE                         = 'x-ms-write';
+    const ETAG                               = 'etag';
+    const LAST_MODIFIED                      = 'last-modified';
+    const DATE                               = 'date';
+    const AUTHENTICATION                     = 'authorization';
+    const WRAP_AUTHORIZATION                 = 'WRAP access_token="%s"';
+    const CONTENT_ENCODING                   = 'content-encoding';
+    const CONTENT_LANGUAGE                   = 'content-language';
+    const CONTENT_LENGTH                     = 'content-length';
+    const CONTENT_LENGTH_NO_SPACE            = 'contentlength';
+    const CONTENT_MD5                        = 'content-md5';
+    const CONTENT_TYPE_LOWER_CASE            = 'content-type';
+    const CONTENT_TYPE                       = 'Content-Type';
+    const CONTENT_ID                         = 'content-id';
+    const CONTENT_RANGE                      = 'content-range';
+    const CACHE_CONTROL                      = 'cache-control';
+    const CONTENT_DISPOSITION                = 'content-disposition';
+    const IF_MODIFIED_SINCE                  = 'if-modified-since';
+    const IF_MATCH                           = 'if-match';
+    const IF_NONE_MATCH                      = 'if-none-match';
+    const IF_UNMODIFIED_SINCE                = 'if-unmodified-since';
+    const RANGE                              = 'range';
+    const DATA_SERVICE_VERSION               = 'dataserviceversion';
+    const MAX_DATA_SERVICE_VERSION           = 'maxdataserviceversion';
+    const ACCEPT_HEADER                      = 'accept';
+    const ACCEPT_CHARSET                     = 'accept-charset';
+    const USER_AGENT                         = 'User-Agent';
+    const PREFER                             = 'Prefer';
+
+    // HTTP Methods
+    const HTTP_GET    = 'GET';
+    const HTTP_PUT    = 'PUT';
+    const HTTP_POST   = 'POST';
+    const HTTP_HEAD   = 'HEAD';
+    const HTTP_DELETE = 'DELETE';
+    const HTTP_MERGE  = 'MERGE';
+
+    // Misc
+    const EMPTY_STRING           = '';
+    const SEPARATOR              = ',';
+    const AZURE_DATE_FORMAT      = 'D, d M Y H:i:s T';
+    const TIMESTAMP_FORMAT       = 'Y-m-d H:i:s';
+    const EMULATED               = 'EMULATED';
+    const EMULATOR_BLOB_URI      = '127.0.0.1:10000';
+    const EMULATOR_QUEUE_URI     = '127.0.0.1:10001';
+    const EMULATOR_TABLE_URI     = '127.0.0.1:10002';
+    const ASTERISK               = '*';
+    const SERVICE_MANAGEMENT_URL = 'https://management.core.windows.net';
+    const HTTP_SCHEME            = 'http';
+    const HTTPS_SCHEME           = 'https';
+    const SETTING_NAME           = 'SettingName';
+    const SETTING_CONSTRAINT     = 'SettingConstraint';
+    const DEV_STORE_URI          = 'http://127.0.0.1';
+    const SERVICE_URI_FORMAT     = "%s://%s.%s";
+    const WRAP_ENDPOINT_URI_FORMAT = "https://%s-sb.accesscontrol.windows.net/WRAPv0.9";
+    const MB_IN_BYTES_1       = 1048576;
+    const MB_IN_BYTES_4       = 4194304;
+    const MB_IN_BYTES_32      = 33554432;
+    const MB_IN_BYTES_64      = 67108864;
+    const MB_IN_BYTES_128     = 134217728;
+    const MB_IN_BYTES_256     = 268435456;
+    const MB_IN_BYTES_100     = 104857600;
+    const GB_IN_BYTES         = 1073741824;
+    const GB_IN_BYTES_200     = 214748364800;
+    const MAX_BLOB_BLOCKS     = 50000;
+    const MAX_BLOCK_BLOB_SIZE = 5242880000000;
+    const RETURN_CONTENT      = 'return-content';
+    const NUMBER_OF_CONCURRENCY = 25;//Guzzle's default value
+    const DEFAULT_NUMBER_OF_RETRIES = 3;
+    const DEFAULT_RETRY_INTERVAL = 1000;//Milliseconds
+    const BEARER = 'Bearer ';
+
+    // Header values
+    const COMMON_SDK_VERSION                 = '1.5.2';
+    const INT32_MAX                          = 2147483647;
+    const INT32_MIN                          = -2147483648;
+
+    // Query parameter names
+    const QP_ENTRIES            = 'Entries';
+    const QP_PREFIX             = 'Prefix';
+    const QP_PREFIX_LOWERCASE   = 'prefix';
+    const QP_MAX_RESULTS        = 'MaxResults';
+    const QP_MAX_RESULTS_LOWERCASE = 'maxresults';
+    const QP_MARKER             = 'Marker';
+    const QP_MARKER_LOWERCASE   = 'marker';
+    const QP_METADATA           = 'Metadata';
+    const QP_NEXT_MARKER        = 'NextMarker';
+    const QP_COMP               = 'comp';
+    const QP_INCLUDE            = 'include';
+    const QP_TIMEOUT            = 'timeout';
+    const QP_REST_TYPE          = 'restype';
+    const QP_SNAPSHOT           = 'snapshot';
+    const QP_COPY_ID            = 'copyid';
+    const QP_NAME               = 'Name';
+    const QP_PROPERTIES         = 'Properties';
+    const QP_LAST_MODIFIED      = 'Last-Modified';
+    const QP_ETAG               = 'Etag';
+    const QP_QUOTA              = 'Quota';
+    const QP_CONTENT_LENGTH     = 'Content-Length';
+
+    // Request body content types
+    const URL_ENCODED_CONTENT_TYPE = 'application/x-www-form-urlencoded';
+    const BINARY_FILE_TYPE         = 'application/octet-stream';
+    const HTTP_TYPE                = 'application/http';
+    const MULTIPART_MIXED_TYPE     = 'multipart/mixed';
+
+    // Common used XML tags
+    const XTAG_ATTRIBUTES                   = '@attributes';
+    const XTAG_NAMESPACE                    = '@namespace';
+    const XTAG_LABEL                        = 'Label';
+    const XTAG_NAME                         = 'Name';
+    const XTAG_DESCRIPTION                  = 'Description';
+    const XTAG_LOCATION                     = 'Location';
+    const XTAG_AFFINITY_GROUP               = 'AffinityGroup';
+    const XTAG_HOSTED_SERVICES              = 'HostedServices';
+    const XTAG_STORAGE_SERVICES             = 'StorageServices';
+    const XTAG_STORAGE_SERVICE              = 'StorageService';
+    const XTAG_DISPLAY_NAME                 = 'DisplayName';
+    const XTAG_SERVICE_NAME                 = 'ServiceName';
+    const XTAG_URL                          = 'Url';
+    const XTAG_ID                           = 'ID';
+    const XTAG_STATUS                       = 'Status';
+    const XTAG_HTTP_STATUS_CODE             = 'HttpStatusCode';
+    const XTAG_CODE                         = 'Code';
+    const XTAG_MESSAGE                      = 'Message';
+    const XTAG_STORAGE_SERVICE_PROPERTIES   = 'StorageServiceProperties';
+    const XTAG_SERVICE_ENDPOINT             = 'ServiceEndpoint';
+    const XTAG_ENDPOINT                     = 'Endpoint';
+    const XTAG_ENDPOINTS                    = 'Endpoints';
+    const XTAG_PRIMARY                      = 'Primary';
+    const XTAG_SECONDARY                    = 'Secondary';
+    const XTAG_KEY_TYPE                     = 'KeyType';
+    const XTAG_STORAGE_SERVICE_KEYS         = 'StorageServiceKeys';
+    const XTAG_ERROR                        = 'Error';
+    const XTAG_HOSTED_SERVICE               = 'HostedService';
+    const XTAG_HOSTED_SERVICE_PROPERTIES    = 'HostedServiceProperties';
+    const XTAG_CREATE_HOSTED_SERVICE        = 'CreateHostedService';
+    const XTAG_CREATE_STORAGE_SERVICE_INPUT = 'CreateStorageServiceInput';
+    const XTAG_UPDATE_STORAGE_SERVICE_INPUT = 'UpdateStorageServiceInput';
+    const XTAG_CREATE_AFFINITY_GROUP        = 'CreateAffinityGroup';
+    const XTAG_UPDATE_AFFINITY_GROUP        = 'UpdateAffinityGroup';
+    const XTAG_UPDATE_HOSTED_SERVICE        = 'UpdateHostedService';
+    const XTAG_PACKAGE_URL                  = 'PackageUrl';
+    const XTAG_CONFIGURATION                = 'Configuration';
+    const XTAG_START_DEPLOYMENT             = 'StartDeployment';
+    const XTAG_TREAT_WARNINGS_AS_ERROR      = 'TreatWarningsAsError';
+    const XTAG_CREATE_DEPLOYMENT            = 'CreateDeployment';
+    const XTAG_DEPLOYMENT_SLOT              = 'DeploymentSlot';
+    const XTAG_PRIVATE_ID                   = 'PrivateID';
+    const XTAG_ROLE_INSTANCE_LIST           = 'RoleInstanceList';
+    const XTAG_UPGRADE_DOMAIN_COUNT         = 'UpgradeDomainCount';
+    const XTAG_ROLE_LIST                    = 'RoleList';
+    const XTAG_SDK_VERSION                  = 'SdkVersion';
+    const XTAG_INPUT_ENDPOINT_LIST          = 'InputEndpointList';
+    const XTAG_LOCKED                       = 'Locked';
+    const XTAG_ROLLBACK_ALLOWED             = 'RollbackAllowed';
+    const XTAG_UPGRADE_STATUS               = 'UpgradeStatus';
+    const XTAG_UPGRADE_TYPE                 = 'UpgradeType';
+    const XTAG_CURRENT_UPGRADE_DOMAIN_STATE = 'CurrentUpgradeDomainState';
+    const XTAG_CURRENT_UPGRADE_DOMAIN       = 'CurrentUpgradeDomain';
+    const XTAG_ROLE_NAME                    = 'RoleName';
+    const XTAG_INSTANCE_NAME                = 'InstanceName';
+    const XTAG_INSTANCE_STATUS              = 'InstanceStatus';
+    const XTAG_INSTANCE_UPGRADE_DOMAIN      = 'InstanceUpgradeDomain';
+    const XTAG_INSTANCE_FAULT_DOMAIN        = 'InstanceFaultDomain';
+    const XTAG_INSTANCE_SIZE                = 'InstanceSize';
+    const XTAG_INSTANCE_STATE_DETAILS       = 'InstanceStateDetails';
+    const XTAG_INSTANCE_ERROR_CODE          = 'InstanceErrorCode';
+    const XTAG_OS_VERSION                   = 'OsVersion';
+    const XTAG_ROLE_INSTANCE                = 'RoleInstance';
+    const XTAG_ROLE                         = 'Role';
+    const XTAG_INPUT_ENDPOINT               = 'InputEndpoint';
+    const XTAG_VIP                          = 'Vip';
+    const XTAG_PORT                         = 'Port';
+    const XTAG_DEPLOYMENT                   = 'Deployment';
+    const XTAG_DEPLOYMENTS                  = 'Deployments';
+    const XTAG_REGENERATE_KEYS              = 'RegenerateKeys';
+    const XTAG_SWAP                         = 'Swap';
+    const XTAG_PRODUCTION                   = 'Production';
+    const XTAG_SOURCE_DEPLOYMENT            = 'SourceDeployment';
+    const XTAG_CHANGE_CONFIGURATION         = 'ChangeConfiguration';
+    const XTAG_MODE                         = 'Mode';
+    const XTAG_UPDATE_DEPLOYMENT_STATUS     = 'UpdateDeploymentStatus';
+    const XTAG_ROLE_TO_UPGRADE              = 'RoleToUpgrade';
+    const XTAG_FORCE                        = 'Force';
+    const XTAG_UPGRADE_DEPLOYMENT           = 'UpgradeDeployment';
+    const XTAG_UPGRADE_DOMAIN               = 'UpgradeDomain';
+    const XTAG_WALK_UPGRADE_DOMAIN          = 'WalkUpgradeDomain';
+    const XTAG_ROLLBACK_UPDATE_OR_UPGRADE   = 'RollbackUpdateOrUpgrade';
+    const XTAG_CONTAINER_NAME               = 'ContainerName';
+    const XTAG_ACCOUNT_NAME                 = 'AccountName';
+    const XTAG_LOGGING                      = 'Logging';
+    const XTAG_HOUR_METRICS                 = 'HourMetrics';
+    const XTAG_MINUTE_METRICS               = 'MinuteMetrics';
+    const XTAG_CORS                         = 'Cors';
+    const XTAG_CORS_RULE                    = 'CorsRule';
+    const XTAG_ALLOWED_ORIGINS              = 'AllowedOrigins';
+    const XTAG_ALLOWED_METHODS              = 'AllowedMethods';
+    const XTAG_ALLOWED_HEADERS              = 'AllowedHeaders';
+    const XTAG_EXPOSED_HEADERS              = 'ExposedHeaders';
+    const XTAG_MAX_AGE_IN_SECONDS           = 'MaxAgeInSeconds';
+    const XTAG_SIGNED_IDENTIFIERS           = 'SignedIdentifiers';
+    const XTAG_SIGNED_IDENTIFIER            = 'SignedIdentifier';
+    const XTAG_ACCESS_POLICY                = 'AccessPolicy';
+    const XTAG_SIGNED_START                 = 'Start';
+    const XTAG_SIGNED_EXPIRY                = 'Expiry';
+    const XTAG_SIGNED_PERMISSION            = 'Permission';
+    const XTAG_SIGNED_ID                    = 'Id';
+    const XTAG_DEFAULT_SERVICE_VERSION      = 'DefaultServiceVersion';
+    const XTAG_GEO_REPLICATION              = 'GeoReplication';
+    const XTAG_LAST_SYNC_TIME               = 'LastSyncTime';
+    const XTAG_PAGE_RANGE                   = 'PageRange';
+    const XTAG_CLEAR_RANGE                  = 'ClearRange';
+    const XTAG_RANGE_START                  = 'Start';
+    const XTAG_RANGE_END                    = 'End';
+
+    // PHP URL Keys
+    const PHP_URL_SCHEME   = 'scheme';
+    const PHP_URL_HOST     = 'host';
+    const PHP_URL_PORT     = 'port';
+    const PHP_URL_USER     = 'user';
+    const PHP_URL_PASS     = 'pass';
+    const PHP_URL_PATH     = 'path';
+    const PHP_URL_QUERY    = 'query';
+    const PHP_URL_FRAGMENT = 'fragment';
+
+    // Status Codes
+    const STATUS_OK                = 200;
+    const STATUS_CREATED           = 201;
+    const STATUS_ACCEPTED          = 202;
+    const STATUS_NO_CONTENT        = 204;
+    const STATUS_PARTIAL_CONTENT   = 206;
+    const STATUS_MOVED_PERMANENTLY = 301;
+
+    // Resource Types
+    const RESOURCE_TYPE_BLOB      = 'b';
+    const RESOURCE_TYPE_CONTAINER = 'c';
+    const RESOURCE_TYPE_QUEUE     = 'q';
+    const RESOURCE_TYPE_TABLE     = 't';
+    const RESOURCE_TYPE_SHARE     = 's';
+    const RESOURCE_TYPE_FILE      = 'f';
+
+    // Request Options String
+    const ROS_LOCATION_MODE  = 'location_mode';
+    const ROS_SECONDARY_URI  = 'secondary_uri';
+    const ROS_PRIMARY_URI    = 'primary_uri';
+    const ROS_DECODE_CONTENT = 'decode_content';
+    const ROS_STREAM         = 'stream';
+    const ROS_HANDLER        = 'requestHandler';
+
+    // @codingStandardsIgnoreEnd
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/RestProxy.php

@@ -0,0 +1,131 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+use MicrosoftAzure\Storage\Common\Internal\IMiddleware;
+
+/**
+ * Base class for all REST proxies.
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class RestProxy
+{
+    /**
+     * @var array
+     */
+    private $middlewares;
+
+    /**
+     * @var Serialization\ISerializer
+     */
+    protected $dataSerializer;
+
+    /**
+     * Initializes new RestProxy object.
+     *
+     * @param Serialization\ISerializer $dataSerializer The data serializer.
+     */
+    public function __construct(Serialization\ISerializer $dataSerializer = null)
+    {
+        $this->middlewares    = array();
+        $this->dataSerializer = $dataSerializer;
+        //For logging the request and responses.
+        // $this->middlewares[] = new HistoryMiddleware('.\\messages.log');
+    }
+
+    /**
+     * Gets middlewares that will be handling the request and response.
+     *
+     * @return array
+     */
+    public function getMiddlewares()
+    {
+        return $this->middlewares;
+    }
+
+    /**
+     * Push a new middleware into the middlewares array. The newly added
+     * middleware will be the most inner middleware when executed.
+     *
+     * @param  callable|IMiddleware $middleware the middleware to be added.
+     *
+     * @return void
+     */
+    public function pushMiddleware($middleware)
+    {
+        $this->middlewares[] = $middleware;
+    }
+
+    /**
+     * Adds optional query parameter.
+     *
+     * Doesn't add the value if it satisfies empty().
+     *
+     * @param array  &$queryParameters The query parameters.
+     * @param string $key              The query variable name.
+     * @param string $value            The query variable value.
+     *
+     * @return void
+     */
+    protected function addOptionalQueryParam(array &$queryParameters, $key, $value)
+    {
+        Validate::isArray($queryParameters, 'queryParameters');
+        Validate::canCastAsString($key, 'key');
+        Validate::canCastAsString($value, 'value');
+
+        if (!is_null($value) && Resources::EMPTY_STRING !== $value) {
+            $queryParameters[$key] = $value;
+        }
+    }
+
+    /**
+     * 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 void
+     */
+    protected function addOptionalHeader(array &$headers, $key, $value)
+    {
+        Validate::isArray($headers, 'headers');
+        Validate::canCastAsString($key, 'key');
+        Validate::canCastAsString($value, 'value');
+
+        if (!is_null($value) && Resources::EMPTY_STRING !== $value) {
+            $headers[$key] = $value;
+        }
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Serialization/ISerializer.php

@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Serialization
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Serialization;
+
+/**
+ * The serialization interface.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Serialization
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+interface ISerializer
+{
+    /**
+     * Serialize an object into a XML.
+     *
+     * @param Object $targetObject The target object to be serialized.
+     * @param string $rootName     The name of the root.
+     *
+     * @return string
+     */
+    public static function objectSerialize($targetObject, $rootName);
+
+    /**
+     * Serializes given array. The array indices must be string to use them as
+     * as element name.
+     *
+     * @param array $array      The object to serialize represented in array.
+     * @param array $properties The used properties in the serialization process.
+     *
+     * @return string
+     */
+    public function serialize(array $array, array $properties = null);
+
+
+    /**
+     * Unserializes given serialized string.
+     *
+     * @param string $serialized The serialized object in string representation.
+     *
+     * @return array
+     */
+    public function unserialize($serialized);
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Serialization/JsonSerializer.php

@@ -0,0 +1,96 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Serialization
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Serialization;
+
+use MicrosoftAzure\Storage\Common\Internal\Validate;
+
+/**
+ * Perform JSON serialization / deserialization
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Serialization
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class JsonSerializer implements ISerializer
+{
+    /**
+     * 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::canCastAsString($rootName, 'rootName');
+
+        $contianer = new \stdClass();
+
+        $contianer->$rootName = $targetObject;
+
+        return json_encode($contianer);
+    }
+
+    /**
+     * Serializes given array. The array indices must be string to use them as
+     * as element name.
+     *
+     * @param array $array      The object to serialize represented in array.
+     * @param array $properties The used properties in the serialization process.
+     *
+     * @return string
+     */
+    public function serialize(array $array = null, array $properties = null)
+    {
+        Validate::isArray($array, 'array');
+
+        return json_encode($array);
+    }
+
+    /**
+     * Unserializes given serialized string to array.
+     *
+     * @param string $serialized The serialized object in string representation.
+     *
+     * @return array
+     */
+    public function unserialize($serialized)
+    {
+        Validate::canCastAsString($serialized, 'serialized');
+
+        $json = json_decode($serialized);
+        if ($json && !is_array($json)) {
+            return get_object_vars($json);
+        } else {
+            return $json;
+        }
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Serialization/MessageSerializer.php

@@ -0,0 +1,178 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Serialization
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Serialization;
+
+use MicrosoftAzure\Storage\Common\Internal\Validate;
+use MicrosoftAzure\Storage\Common\Internal\Resources;
+use GuzzleHttp\Exception\RequestException;
+
+/**
+ * Provides functionality to serialize a message to a string.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Serialization
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class MessageSerializer
+{
+    /**
+     * Serialize a message to a string. The message object must be either a type
+     * of \Exception, or have following methods implemented.
+     * getHeaders()
+     * getProtocolVersion()
+     * (getUri() && getMethod()) || (getStatusCode() && getReasonPhrase())
+     *
+     * @param object $message The message to be serialized.
+     *
+     * @return string
+     */
+    public static function objectSerialize($targetObject)
+    {
+        //if the object is of exception type, serialize it using the methods
+        //without checking the methods.
+        if ($targetObject instanceof RequestException) {
+            return self::serializeRequestException($targetObject);
+        } elseif ($targetObject instanceof \Exception) {
+            return self::serializeException($targetObject);
+        }
+
+        Validate::methodExists($targetObject, 'getHeaders', 'targetObject');
+        Validate::methodExists($targetObject, 'getProtocolVersion', 'targetObject');
+
+        // Serialize according to the implemented method.
+        if (method_exists($targetObject, 'getUri') &&
+            method_exists($targetObject, 'getMethod')) {
+            return self::serializeRequest($targetObject);
+        } elseif (method_exists($targetObject, 'getStatusCode') &&
+                   method_exists($targetObject, 'getReasonPhrase')) {
+            return self::serializeResponse($targetObject);
+        } else {
+            throw new \InvalidArgumentException(
+                Resources::INVALID_MESSAGE_OBJECT_TO_SERIALIZE
+            );
+        }
+    }
+
+    /**
+     * Serialize the request type that implemented the following methods:
+     * getHeaders()
+     * getProtocolVersion()
+     * getUri()
+     * getMethod()
+     *
+     * @param  object $request The request to be serialized.
+     *
+     * @return string
+     */
+    private static function serializeRequest($request)
+    {
+        $headers = $request->getHeaders();
+        $version = $request->getProtocolVersion();
+        $uri     = $request->getUri();
+        $method  = $request->getMethod();
+
+        $resultString = "Request:\n";
+        $resultString .= "URI: {$uri}\nHTTP Version: {$version}\nMethod: {$method}\n";
+        $resultString .= self::serializeHeaders($headers);
+
+        return $resultString;
+    }
+
+    /**
+     * Serialize the response type that implemented the following methods:
+     * getHeaders()
+     * getProtocolVersion()
+     * getStatusCode()
+     * getReasonPhrase()
+     *
+     * @param  object $response The response to be serialized
+     *
+     * @return string
+     */
+    private static function serializeResponse($response)
+    {
+        $headers = $response->getHeaders();
+        $version = $response->getProtocolVersion();
+        $status  = $response->getStatusCode();
+        $reason  = $response->getReasonPhrase();
+
+        $resultString = "Response:\n";
+        $resultString .= "Status Code: {$status}\nReason: {$reason}\n";
+        $resultString .= "HTTP Version: {$version}\n";
+        $resultString .= self::serializeHeaders($headers);
+
+        return $resultString;
+    }
+
+    /**
+     * Serialize the message headers.
+     *
+     * @param  array  $headers The headers to be serialized.
+     *
+     * @return string
+     */
+    private static function serializeHeaders(array $headers)
+    {
+        $resultString = "Headers:\n";
+        foreach ($headers as $key => $value) {
+            $resultString .= sprintf("%s: %s\n", $key, $value[0]);
+        }
+
+        return $resultString;
+    }
+
+    /**
+     * Serialize the request exception.
+     *
+     * @param  RequestException $e the request exception to be serialized.
+     *
+     * @return string
+     */
+    private static function serializeRequestException(RequestException $e)
+    {
+        $resultString = sprintf("Reason:\n%s\n", $e);
+        if ($e->hasResponse()) {
+            $resultString .= self::serializeResponse($e->getResponse());
+        }
+
+        return $resultString;
+    }
+
+    /**
+     * Serialize the general exception
+     *
+     * @param  \Exception $e general exception to be serialized.
+     *
+     * @return string
+     */
+    private static function serializeException(\Exception $e)
+    {
+        return sprintf("Reason:\n%s\n", $e);
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Serialization/XmlSerializer.php

@@ -0,0 +1,245 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Serialization
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal\Serialization;
+
+use MicrosoftAzure\Storage\Common\Internal\Utilities;
+use MicrosoftAzure\Storage\Common\Internal\Resources;
+use MicrosoftAzure\Storage\Common\Internal\Validate;
+
+/**
+ * Short description
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal\Serialization
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class XmlSerializer implements ISerializer
+{
+    const STANDALONE  = 'standalone';
+    const ROOT_NAME   = 'rootName';
+    const DEFAULT_TAG = 'defaultTag';
+
+    /**
+     * Converts a SimpleXML object to an Array recursively
+     * ensuring all sub-elements are arrays as well.
+     *
+     * @param string $sxml The SimpleXML object.
+     * @param array  $arr  The array into which to store results.
+     *
+     * @return array
+     */
+    private function sxml2arr($sxml, array $arr = null)
+    {
+        foreach ((array) $sxml as $key => $value) {
+            if (is_object($value) || (is_array($value))) {
+                $arr[$key] = $this->sxml2arr($value);
+            } else {
+                $arr[$key] = $value;
+            }
+        }
+
+        return $arr;
+    }
+
+    /**
+     * Takes an array and produces XML based on it.
+     *
+     * @param XMLWriter $xmlw       XMLWriter object that was previously instanted
+     * and is used for creating the XML.
+     * @param array     $data       Array to be converted to XML.
+     * @param string    $defaultTag Default XML tag to be used if none specified.
+     *
+     * @return void
+     */
+    private function arr2xml(\XMLWriter $xmlw, array $data, $defaultTag = null)
+    {
+        foreach ($data as $key => $value) {
+            if ($key === Resources::XTAG_ATTRIBUTES) {
+                foreach ($value as $attributeName => $attributeValue) {
+                    $xmlw->writeAttribute($attributeName, $attributeValue);
+                }
+            } elseif (is_array($value)) {
+                if (!is_int($key)) {
+                    if ($key != Resources::EMPTY_STRING) {
+                        $xmlw->startElement($key);
+                    } else {
+                        $xmlw->startElement($defaultTag);
+                    }
+                }
+
+                $this->arr2xml($xmlw, $value);
+
+                if (!is_int($key)) {
+                    $xmlw->endElement();
+                }
+            } else {
+                $xmlw->writeElement($key, $value);
+            }
+        }
+    }
+
+    /**
+     * Gets the attributes of a specified object if get attributes
+     * method is exposed.
+     *
+     * @param object $targetObject The target object.
+     * @param array  $methodArray  The array of method of the target object.
+     *
+     * @return mixed
+     */
+    private static function getInstanceAttributes($targetObject, array $methodArray)
+    {
+        foreach ($methodArray as $method) {
+            if ($method->name == 'getAttributes') {
+                $classProperty = $method->invoke($targetObject);
+                return $classProperty;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 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::canCastAsString($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);
+    }
+
+    /**
+     * Serializes given array. The array indices must be string to use them as
+     * as element name.
+     *
+     * @param array $array      The object to serialize represented in array.
+     * @param array $properties The used properties in the serialization process.
+     *
+     * @return string
+     */
+    public function serialize(array $array, array $properties = null)
+    {
+        $xmlVersion   = '1.0';
+        $xmlEncoding  = 'UTF-8';
+        $standalone   = Utilities::tryGetValue($properties, self::STANDALONE);
+        $defaultTag   = Utilities::tryGetValue($properties, self::DEFAULT_TAG);
+        $rootName     = Utilities::tryGetValue($properties, self::ROOT_NAME);
+        $docNamespace = Utilities::tryGetValue(
+            $array,
+            Resources::XTAG_NAMESPACE,
+            null
+        );
+
+        if (!is_array($array)) {
+            return false;
+        }
+
+        $xmlw = new \XmlWriter();
+        $xmlw->openMemory();
+        $xmlw->setIndent(true);
+        $xmlw->startDocument($xmlVersion, $xmlEncoding, $standalone);
+
+        if (is_null($docNamespace)) {
+            $xmlw->startElement($rootName);
+        } else {
+            foreach ($docNamespace as $uri => $prefix) {
+                $xmlw->startElementNS($prefix, $rootName, $uri);
+                break;
+            }
+        }
+
+        unset($array[Resources::XTAG_NAMESPACE]);
+        self::arr2xml($xmlw, $array, $defaultTag);
+
+        $xmlw->endElement();
+
+        return $xmlw->outputMemory(true);
+    }
+
+    /**
+     * Unserializes given serialized string.
+     *
+     * @param string $serialized The serialized object in string representation.
+     *
+     * @return array
+     */
+    public function unserialize($serialized)
+    {
+        $sxml = new \SimpleXMLElement($serialized);
+
+        return $this->sxml2arr($sxml);
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/ServiceRestProxy.php

@@ -0,0 +1,658 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;
+use MicrosoftAzure\Storage\Common\Internal\RetryMiddlewareFactory;
+use MicrosoftAzure\Storage\Common\Internal\Serialization\XmlSerializer;
+use MicrosoftAzure\Storage\Common\Models\ServiceOptions;
+use MicrosoftAzure\Storage\Common\Internal\Http\HttpCallContext;
+use MicrosoftAzure\Storage\Common\Internal\Middlewares\MiddlewareBase;
+use MicrosoftAzure\Storage\Common\Middlewares\MiddlewareStack;
+use MicrosoftAzure\Storage\Common\LocationMode;
+use GuzzleHttp\Promise\EachPromise;
+use GuzzleHttp\Exception\RequestException;
+use GuzzleHttp\Psr7\Request;
+use GuzzleHttp\Psr7\Uri;
+use GuzzleHttp\Client;
+use GuzzleHttp\Psr7;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Base class for all services rest proxies.
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class ServiceRestProxy extends RestProxy
+{
+    private $accountName;
+    private $psrPrimaryUri;
+    private $psrSecondaryUri;
+    private $options;
+    private $client;
+
+    /**
+     * Initializes new ServiceRestProxy object.
+     *
+     * @param string                    $primaryUri     The storage account
+     *                                                  primary uri.
+     * @param string                    $secondaryUri   The storage account
+     *                                                  secondary uri.
+     * @param string                    $accountName    The name of the account.
+     * @param array                     $options        Array of options for
+     *                                                  the service
+     */
+    public function __construct(
+        $primaryUri,
+        $secondaryUri,
+        $accountName,
+        array $options = []
+    ) {
+        $primaryUri   = Utilities::appendDelimiter($primaryUri, '/');
+        $secondaryUri = Utilities::appendDelimiter($secondaryUri, '/');
+
+        $dataSerializer = new XmlSerializer();
+        parent::__construct($dataSerializer);
+
+        $this->accountName     = $accountName;
+        $this->psrPrimaryUri   = new Uri($primaryUri);
+        $this->psrSecondaryUri = new Uri($secondaryUri);
+        $this->options         = array_merge(array('http' => array()), $options);
+        $this->client          = self::createClient($this->options['http']);
+    }
+
+    /**
+     * Create a Guzzle client for future usage.
+     *
+     * @param  array $options Optional parameters for the client.
+     *
+     * @return Client
+     */
+    private static function createClient(array $options)
+    {
+        $verify = true;
+        //Disable SSL if proxy has been set, and set the proxy in the client.
+        $proxy = getenv('HTTP_PROXY');
+        // For testing with Fiddler
+        // $proxy = 'localhost:8888';
+        // $verify = false;
+        if (!empty($proxy)) {
+            $options['proxy'] = $proxy;
+        }
+
+        if (isset($options['verify'])) {
+            $verify = $options['verify'];
+        }
+
+        return (new \GuzzleHttp\Client(
+            array_merge(
+                $options,
+                array(
+                    "defaults" => array(
+                        "allow_redirects" => true,
+                        "exceptions" => true,
+                        "decode_content" => true,
+                        "config" => [
+                            "curl" => [
+                                CURLOPT_SSLVERSION => CURL_SSLVERSION_TLSv1_2
+                            ]
+                        ]
+                    ),
+                    'cookies' => true,
+                    'verify' => $verify,
+                )
+            )
+        ));
+    }
+
+    /**
+     * Gets the account name.
+     *
+     * @return string
+     */
+    public function getAccountName()
+    {
+        return $this->accountName;
+    }
+
+    /**
+     * Create a middleware stack with given middleware.
+     *
+     * @param  ServiceOptions  $serviceOptions The options user passed in.
+     *
+     * @return MiddlewareStack
+     */
+    protected function createMiddlewareStack(ServiceOptions $serviceOptions)
+    {
+        //If handler stack is not defined by the user, create a default
+        //middleware stack.
+        $stack = null;
+        if (array_key_exists('stack', $this->options['http'])) {
+            $stack = $this->options['http']['stack'];
+        } elseif ($serviceOptions->getMiddlewareStack() != null) {
+            $stack = $serviceOptions->getMiddlewareStack();
+        } else {
+            $stack = new MiddlewareStack();
+        }
+
+        //Push all the middlewares specified in the $serviceOptions to the
+        //handlerstack.
+        if ($serviceOptions->getMiddlewares() != array()) {
+            foreach ($serviceOptions->getMiddlewares() as $middleware) {
+                $stack->push($middleware);
+            }
+        }
+
+        //Push all the middlewares specified in the $options to the
+        //handlerstack.
+        if (array_key_exists('middlewares', $this->options)) {
+            foreach ($this->options['middlewares'] as $middleware) {
+                $stack->push($middleware);
+            }
+        }
+
+        //Push all the middlewares specified in $this->middlewares to the
+        //handlerstack.
+        foreach ($this->getMiddlewares() as $middleware) {
+            $stack->push($middleware);
+        }
+
+        return $stack;
+    }
+
+    /**
+     * Send the requests concurrently. Number of concurrency can be modified
+     * by inserting a new key/value pair with the key 'number_of_concurrency'
+     * into the $requestOptions of $serviceOptions. Return only the promise.
+     *
+     * @param  callable       $generator   the generator function to generate
+     *                                     request upon fulfillment
+     * @param  int            $statusCode  The expected status code for each of the
+     *                                     request generated by generator.
+     * @param  ServiceOptions $options     The service options for the concurrent
+     *                                     requests.
+     *
+     * @return \GuzzleHttp\Promise\Promise|\GuzzleHttp\Promise\PromiseInterface
+     */
+    protected function sendConcurrentAsync(
+        callable $generator,
+        $statusCode,
+        ServiceOptions $options
+    ) {
+        $client = $this->client;
+        $middlewareStack = $this->createMiddlewareStack($options);
+
+        $sendAsync = function ($request, $options) use ($client) {
+            if ($request->getMethod() == 'HEAD') {
+                $options['decode_content'] = false;
+            }
+            return $client->sendAsync($request, $options);
+        };
+
+        $handler = $middlewareStack->apply($sendAsync);
+
+        $requestOptions = $this->generateRequestOptions($options, $handler);
+
+        $promises = \call_user_func(
+            function () use (
+                $generator,
+                $handler,
+                $requestOptions
+            ) {
+                while (is_callable($generator) && ($request = $generator())) {
+                    yield \call_user_func($handler, $request, $requestOptions);
+                }
+            }
+        );
+
+        $eachPromise = new EachPromise($promises, [
+            'concurrency' => $options->getNumberOfConcurrency(),
+            'fulfilled' => function ($response, $index) use ($statusCode) {
+                //the promise is fulfilled, evaluate the response
+                self::throwIfError(
+                    $response,
+                    $statusCode
+                );
+            },
+            'rejected' => function ($reason, $index) {
+                //Still rejected even if the retry logic has been applied.
+                //Throwing exception.
+                throw $reason;
+            }
+        ]);
+
+        return $eachPromise->promise();
+    }
+
+
+    /**
+     * Create the request to be sent.
+     *
+     * @param  string $method         The method of the HTTP request
+     * @param  array  $headers        The header field of the request
+     * @param  array  $queryParams    The query parameter of the request
+     * @param  array  $postParameters The HTTP POST parameters
+     * @param  string $path           URL path
+     * @param  string $body           Request body
+     *
+     * @return \GuzzleHttp\Psr7\Request
+     */
+    protected function createRequest(
+        $method,
+        array $headers,
+        array $queryParams,
+        array $postParameters,
+        $path,
+        $locationMode,
+        $body = Resources::EMPTY_STRING
+    ) {
+        if ($locationMode == LocationMode::SECONDARY_ONLY ||
+            $locationMode == LocationMode::SECONDARY_THEN_PRIMARY) {
+            $uri = $this->psrSecondaryUri;
+        } else {
+            $uri = $this->psrPrimaryUri;
+        }
+
+        //Append the path, not replacing it.
+        if ($path != null) {
+            $exPath = $uri->getPath();
+            if ($exPath != '') {
+                //Remove the duplicated slash in the path.
+                if ($path != '' && $path[0] == '/') {
+                    $path = $exPath . substr($path, 1);
+                } else {
+                    $path = $exPath . $path;
+                }
+            }
+            $uri = $uri->withPath($path);
+        }
+
+        // add query parameters into headers
+        if ($queryParams != null) {
+            $queryString = Psr7\Query::build($queryParams);
+            $uri = $uri->withQuery($queryString);
+        }
+
+        // add post parameters into bodies
+        $actualBody = null;
+        if (empty($body)) {
+            if (empty($headers[Resources::CONTENT_TYPE])) {
+                $headers[Resources::CONTENT_TYPE] = Resources::URL_ENCODED_CONTENT_TYPE;
+                $actualBody = Psr7\Query::build($postParameters);
+            }
+        } else {
+            $actualBody = $body;
+        }
+
+        $request = new Request(
+            $method,
+            $uri,
+            $headers,
+            $actualBody
+        );
+
+        //add content-length to header
+        $bodySize = $request->getBody()->getSize();
+        if ($bodySize > 0) {
+            $request = $request->withHeader('content-length', $bodySize);
+        }
+        return $request;
+    }
+
+    /**
+     * Create promise of sending HTTP request with the specified parameters.
+     *
+     * @param  string         $method         HTTP method used in the request
+     * @param  array          $headers        HTTP headers.
+     * @param  array          $queryParams    URL query parameters.
+     * @param  array          $postParameters The HTTP POST parameters.
+     * @param  string         $path           URL path
+     * @param  array|int      $expected       Expected Status Codes.
+     * @param  string         $body           Request body
+     * @param  ServiceOptions $serviceOptions Service options
+     *
+     * @return \GuzzleHttp\Promise\PromiseInterface
+     */
+    protected function sendAsync(
+        $method,
+        array $headers,
+        array $queryParams,
+        array $postParameters,
+        $path,
+        $expected = Resources::STATUS_OK,
+        $body = Resources::EMPTY_STRING,
+        ServiceOptions $serviceOptions = null
+    ) {
+        if ($serviceOptions == null) {
+            $serviceOptions = new ServiceOptions();
+        }
+        $this->addOptionalQueryParam(
+            $queryParams,
+            Resources::QP_TIMEOUT,
+            $serviceOptions->getTimeout()
+        );
+
+        $request = $this->createRequest(
+            $method,
+            $headers,
+            $queryParams,
+            $postParameters,
+            $path,
+            $serviceOptions->getLocationMode(),
+            $body
+        );
+
+        $client = $this->client;
+
+        $middlewareStack = $this->createMiddlewareStack($serviceOptions);
+
+        $sendAsync = function ($request, $options) use ($client) {
+            return $client->sendAsync($request, $options);
+        };
+
+        $handler = $middlewareStack->apply($sendAsync);
+
+        $requestOptions =
+            $this->generateRequestOptions($serviceOptions, $handler);
+
+        if ($request->getMethod() == 'HEAD') {
+            $requestOptions[Resources::ROS_DECODE_CONTENT] = false;
+        }
+
+        $promise = \call_user_func($handler, $request, $requestOptions);
+
+        return $promise->then(
+            function ($response) use ($expected, $requestOptions) {
+                self::throwIfError(
+                    $response,
+                    $expected
+                );
+
+                return self::addLocationHeaderToResponse(
+                    $response,
+                    $requestOptions[Resources::ROS_LOCATION_MODE]
+                );
+            },
+            function ($reason) use ($expected) {
+                return $this->onRejected($reason, $expected);
+            }
+        );
+    }
+
+    /**
+     * @param  string|\Exception $reason   Rejection reason.
+     * @param  array|int         $expected Expected Status Codes.
+     *
+     * @return ResponseInterface
+     */
+    protected function onRejected($reason, $expected)
+    {
+        if (!($reason instanceof \Exception)) {
+            throw new \RuntimeException($reason);
+        }
+        if (!($reason instanceof RequestException)) {
+            throw $reason;
+        }
+        $response = $reason->getResponse();
+        if ($response != null) {
+            self::throwIfError(
+                $response,
+                $expected
+            );
+        } else {
+            //if could not get response but promise rejected, throw reason.
+            throw $reason;
+        }
+        return $response;
+    }
+
+    /**
+     * Generate the request options using the given service options and stored
+     * information.
+     *
+     * @param  ServiceOptions $serviceOptions The service options used to
+     *                                        generate request options.
+     * @param  callable       $handler        The handler used to send the
+     *                                        request.
+     * @return array
+     */
+    protected function generateRequestOptions(
+        ServiceOptions $serviceOptions,
+        callable $handler
+    ) {
+        $result = array();
+        $result[Resources::ROS_LOCATION_MODE]  = $serviceOptions->getLocationMode();
+        $result[Resources::ROS_STREAM]         = $serviceOptions->getIsStreaming();
+        $result[Resources::ROS_DECODE_CONTENT] = $serviceOptions->getDecodeContent();
+        $result[Resources::ROS_HANDLER]        = $handler;
+        $result[Resources::ROS_SECONDARY_URI]  = $this->getPsrSecondaryUri();
+        $result[Resources::ROS_PRIMARY_URI]    = $this->getPsrPrimaryUri();
+
+        return $result;
+    }
+
+    /**
+     * Sends the context.
+     *
+     * @param  HttpCallContext $context The context of the request.
+     * @return \GuzzleHttp\Psr7\Response
+     */
+    protected function sendContext(HttpCallContext $context)
+    {
+        return $this->sendContextAsync($context)->wait();
+    }
+
+    /**
+     * Creates the promise to send the context.
+     *
+     * @param  HttpCallContext $context The context of the request.
+     *
+     * @return \GuzzleHttp\Promise\PromiseInterface
+     */
+    protected function sendContextAsync(HttpCallContext $context)
+    {
+        return $this->sendAsync(
+            $context->getMethod(),
+            $context->getHeaders(),
+            $context->getQueryParameters(),
+            $context->getPostParameters(),
+            $context->getPath(),
+            $context->getStatusCodes(),
+            $context->getBody(),
+            $context->getServiceOptions()
+        );
+    }
+
+    /**
+     * Throws ServiceException if the received status code is not expected.
+     *
+     * @param ResponseInterface $response The response received
+     * @param array|int         $expected The expected status codes.
+     *
+     * @return void
+     *
+     * @throws ServiceException
+     */
+    public static function throwIfError(ResponseInterface $response, $expected)
+    {
+        $expectedStatusCodes = is_array($expected) ? $expected : array($expected);
+
+        if (!in_array($response->getStatusCode(), $expectedStatusCodes)) {
+            throw new ServiceException($response);
+        }
+    }
+
+    /**
+     * Adds HTTP POST parameter to the specified
+     *
+     * @param array  $postParameters An array of HTTP POST parameters.
+     * @param string $key            The key of a HTTP POST parameter.
+     * @param string $value          the value of a HTTP POST parameter.
+     *
+     * @return array
+     */
+    public function addPostParameter(
+        array $postParameters,
+        $key,
+        $value
+    ) {
+        Validate::isArray($postParameters, 'postParameters');
+        $postParameters[$key] = $value;
+        return $postParameters;
+    }
+
+    /**
+     * Groups set of values into one value separated with Resources::SEPARATOR
+     *
+     * @param array $values array of values to be grouped.
+     *
+     * @return string
+     */
+    public static function groupQueryValues(array $values)
+    {
+        Validate::isArray($values, 'values');
+        $joined = Resources::EMPTY_STRING;
+
+        sort($values);
+
+        foreach ($values as $value) {
+            if (!is_null($value) && !empty($value)) {
+                $joined .= $value . Resources::SEPARATOR;
+            }
+        }
+
+        return trim($joined, Resources::SEPARATOR);
+    }
+
+    /**
+     * Adds metadata elements to headers array
+     *
+     * @param array $headers  HTTP request headers
+     * @param array $metadata user specified metadata
+     *
+     * @return array
+     */
+    protected function addMetadataHeaders(array $headers, array $metadata = null)
+    {
+        Utilities::validateMetadata($metadata);
+
+        $metadata = $this->generateMetadataHeaders($metadata);
+        $headers  = array_merge($headers, $metadata);
+
+        return $headers;
+    }
+
+    /**
+     * Generates metadata headers by prefixing each element with 'x-ms-meta'.
+     *
+     * @param array $metadata user defined metadata.
+     *
+     * @return array
+     */
+    public function generateMetadataHeaders(array $metadata = null)
+    {
+        $metadataHeaders = array();
+
+        if (is_array($metadata) && !is_null($metadata)) {
+            foreach ($metadata as $key => $value) {
+                $headerName = Resources::X_MS_META_HEADER_PREFIX;
+                if (strpos($value, "\r") !== false
+                    || strpos($value, "\n") !== false
+                ) {
+                    throw new \InvalidArgumentException(Resources::INVALID_META_MSG);
+                }
+
+                // Metadata name is case-presrved and case insensitive
+                $headerName                     .= $key;
+                $metadataHeaders[$headerName] = $value;
+            }
+        }
+
+        return $metadataHeaders;
+    }
+
+    /**
+     * Get the primary URI in PSR form.
+     *
+     * @return Uri
+     */
+    public function getPsrPrimaryUri()
+    {
+        return $this->psrPrimaryUri;
+    }
+
+    /**
+     * Get the secondary URI in PSR form.
+     *
+     * @return Uri
+     */
+    public function getPsrSecondaryUri()
+    {
+        return $this->psrSecondaryUri;
+    }
+
+    /**
+     * Adds the header that indicates the location mode to the response header.
+     *
+     * @return  ResponseInterface
+     */
+    private static function addLocationHeaderToResponse(
+        ResponseInterface $response,
+        $locationMode
+    ) {
+        //If the response already has this header, return itself.
+        if ($response->hasHeader(Resources::X_MS_CONTINUATION_LOCATION_MODE)) {
+            return $response;
+        }
+        //Otherwise, add the header that indicates the endpoint to be used if
+        //continuation token is used for subsequent request. Notice that if the
+        //response does not have location header set at the moment, it means
+        //that the user have not set a retry middleware.
+        if ($locationMode == LocationMode::PRIMARY_THEN_SECONDARY) {
+            $response = $response->withHeader(
+                Resources::X_MS_CONTINUATION_LOCATION_MODE,
+                LocationMode::PRIMARY_ONLY
+            );
+        } elseif ($locationMode == LocationMode::SECONDARY_THEN_PRIMARY) {
+            $response = $response->withHeader(
+                Resources::X_MS_CONTINUATION_LOCATION_MODE,
+                LocationMode::SECONDARY_ONLY
+            );
+        } elseif ($locationMode == LocationMode::SECONDARY_ONLY  ||
+                  $locationMode == LocationMode::PRIMARY_ONLY) {
+            $response = $response->withHeader(
+                Resources::X_MS_CONTINUATION_LOCATION_MODE,
+                $locationMode
+            );
+        }
+        return $response;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/ServiceRestTrait.php

@@ -0,0 +1,259 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+use MicrosoftAzure\Storage\Common\LocationMode;
+use MicrosoftAzure\Storage\Common\Models\ServiceOptions;
+use MicrosoftAzure\Storage\Common\Models\ServiceProperties;
+use MicrosoftAzure\Storage\Common\Models\GetServicePropertiesResult;
+use MicrosoftAzure\Storage\Common\Models\GetServiceStatsResult;
+
+/**
+ * Trait implementing common REST API for all the services, including the
+ * following:
+ * Get/Set Service Properties
+ * Get service stats
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2017 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+trait ServiceRestTrait
+{
+    /**
+     * Gets the properties of the service.
+     *
+     * @param ServiceOptions $options The optional parameters.
+     *
+     * @return \MicrosoftAzure\Storage\Common\Models\GetServicePropertiesResult
+     *
+     * @see http://msdn.microsoft.com/en-us/library/windowsazure/hh452239.aspx
+     */
+    public function getServiceProperties(
+        ServiceOptions $options = null
+    ) {
+        return $this->getServicePropertiesAsync($options)->wait();
+    }
+
+    /**
+     * Creates promise to get the properties of the service.
+     *
+     * @param ServiceOptions $options The optional parameters.
+     *
+     * @return \GuzzleHttp\Promise\PromiseInterface
+     *
+     * @see http://msdn.microsoft.com/en-us/library/windowsazure/hh452239.aspx
+     */
+    public function getServicePropertiesAsync(
+        ServiceOptions $options = null
+    ) {
+        $method      = Resources::HTTP_GET;
+        $headers     = array();
+        $queryParams = array();
+        $postParams  = array();
+        $path        = Resources::EMPTY_STRING;
+
+        if (is_null($options)) {
+            $options = new ServiceOptions();
+        }
+
+        $this->addOptionalQueryParam(
+            $queryParams,
+            Resources::QP_REST_TYPE,
+            'service'
+        );
+        $this->addOptionalQueryParam(
+            $queryParams,
+            Resources::QP_COMP,
+            'properties'
+        );
+
+        $dataSerializer = $this->dataSerializer;
+
+        return $this->sendAsync(
+            $method,
+            $headers,
+            $queryParams,
+            $postParams,
+            $path,
+            Resources::STATUS_OK,
+            Resources::EMPTY_STRING,
+            $options
+        )->then(function ($response) use ($dataSerializer) {
+            $parsed = $dataSerializer->unserialize($response->getBody());
+            return GetServicePropertiesResult::create($parsed);
+        }, null);
+    }
+
+    /**
+     * Sets the properties of the service.
+     *
+     * It's recommended to use getServiceProperties, alter the returned object and
+     * then use setServiceProperties with this altered object.
+     *
+     * @param ServiceProperties $serviceProperties The service properties.
+     * @param ServiceOptions    $options           The optional parameters.
+     *
+     * @return void
+     *
+     * @see http://msdn.microsoft.com/en-us/library/windowsazure/hh452235.aspx
+     */
+    public function setServiceProperties(
+        ServiceProperties $serviceProperties,
+        ServiceOptions $options = null
+    ) {
+        $this->setServicePropertiesAsync($serviceProperties, $options)->wait();
+    }
+
+    /**
+     * Creates the promise to set the properties of the service.
+     *
+     * It's recommended to use getServiceProperties, alter the returned object and
+     * then use setServiceProperties with this altered object.
+     *
+     * @param ServiceProperties $serviceProperties The service properties.
+     * @param ServiceOptions    $options           The optional parameters.
+     *
+     * @return \GuzzleHttp\Promise\PromiseInterface
+     *
+     * @see http://msdn.microsoft.com/en-us/library/windowsazure/hh452235.aspx
+     */
+    public function setServicePropertiesAsync(
+        ServiceProperties $serviceProperties,
+        ServiceOptions $options = null
+    ) {
+        Validate::isTrue(
+            $serviceProperties instanceof ServiceProperties,
+            Resources::INVALID_SVC_PROP_MSG
+        );
+
+        $method      = Resources::HTTP_PUT;
+        $headers     = array();
+        $queryParams = array();
+        $postParams  = array();
+        $path        = Resources::EMPTY_STRING;
+        $body        = $serviceProperties->toXml($this->dataSerializer);
+
+        if (is_null($options)) {
+            $options = new ServiceOptions();
+        }
+
+        $this->addOptionalQueryParam(
+            $queryParams,
+            Resources::QP_REST_TYPE,
+            'service'
+        );
+        $this->addOptionalQueryParam(
+            $queryParams,
+            Resources::QP_COMP,
+            'properties'
+        );
+        $this->addOptionalHeader(
+            $headers,
+            Resources::CONTENT_TYPE,
+            Resources::URL_ENCODED_CONTENT_TYPE
+        );
+
+        $options->setLocationMode(LocationMode::PRIMARY_ONLY);
+
+        return $this->sendAsync(
+            $method,
+            $headers,
+            $queryParams,
+            $postParams,
+            $path,
+            Resources::STATUS_ACCEPTED,
+            $body,
+            $options
+        );
+    }
+
+    /**
+     * Retrieves statistics related to replication for the service. The operation
+     * will only be sent to secondary location endpoint.
+     *
+     * @param  ServiceOptions|null $options The options this operation sends with.
+     *
+     * @return GetServiceStatsResult
+     */
+    public function getServiceStats(ServiceOptions $options = null)
+    {
+        return $this->getServiceStatsAsync($options)->wait();
+    }
+
+    /**
+     * Creates promise that retrieves statistics related to replication for the
+     * service. The operation will only be sent to secondary location endpoint.
+     *
+     * @param  ServiceOptions|null $options The options this operation sends with.
+     *
+     * @return \GuzzleHttp\Promise\PromiseInterface
+     */
+    public function getServiceStatsAsync(ServiceOptions $options = null)
+    {
+        $method      = Resources::HTTP_GET;
+        $headers     = array();
+        $queryParams = array();
+        $postParams  = array();
+        $path        = Resources::EMPTY_STRING;
+
+        if (is_null($options)) {
+            $options = new ServiceOptions();
+        }
+
+        $this->addOptionalQueryParam(
+            $queryParams,
+            Resources::QP_REST_TYPE,
+            'service'
+        );
+        $this->addOptionalQueryParam(
+            $queryParams,
+            Resources::QP_COMP,
+            'stats'
+        );
+
+        $dataSerializer = $this->dataSerializer;
+
+        $options->setLocationMode(LocationMode::SECONDARY_ONLY);
+
+        return $this->sendAsync(
+            $method,
+            $headers,
+            $queryParams,
+            $postParams,
+            $path,
+            Resources::STATUS_OK,
+            Resources::EMPTY_STRING,
+            $options
+        )->then(function ($response) use ($dataSerializer) {
+            $parsed = $dataSerializer->unserialize($response->getBody());
+            return GetServiceStatsResult::create($parsed);
+        }, null);
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/ServiceSettings.php

@@ -0,0 +1,288 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+/**
+ * Base class for all REST services settings.
+ *
+ * Derived classes must implement the following members:
+ * 1- $isInitialized: A static property that indicates whether the class's static
+ *    members have been initialized.
+ * 2- init(): A protected static method that initializes static members.
+ * 3- $validSettingKeys: A static property that contains valid setting keys for this
+ *    service.
+ * 4- createFromConnectionString($connectionString): A public static function that
+ *    takes a connection string and returns the created settings object.
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+abstract class ServiceSettings
+{
+    /**
+     * Throws an exception if the connection string format does not match any of the
+     * available formats.
+     *
+     * @param string $connectionString The invalid formatted connection string.
+     *
+     * @return void
+     *
+     * @throws \RuntimeException
+     */
+    protected static function noMatch($connectionString)
+    {
+        throw new \RuntimeException(
+            sprintf(Resources::MISSING_CONNECTION_STRING_SETTINGS, $connectionString)
+        );
+    }
+
+    /**
+     * Parses the connection string and then validate that the parsed keys belong to
+     * the $validSettingKeys
+     *
+     * @param string $connectionString The user provided connection string.
+     *
+     * @return array The tokenized connection string keys.
+     *
+     * @throws \RuntimeException
+     */
+    protected static function parseAndValidateKeys($connectionString)
+    {
+        // Initialize the static values if they are not initialized yet.
+        if (!static::$isInitialized) {
+            static::init();
+            static::$isInitialized = true;
+        }
+
+        $tokenizedSettings = ConnectionStringParser::parseConnectionString(
+            'connectionString',
+            $connectionString
+        );
+
+        // Assure that all given keys are valid.
+        foreach ($tokenizedSettings as $key => $value) {
+            if (!Utilities::inArrayInsensitive($key, static::$validSettingKeys)) {
+                throw new \RuntimeException(
+                    sprintf(
+                        Resources::INVALID_CONNECTION_STRING_SETTING_KEY,
+                        $key,
+                        implode("\n", static::$validSettingKeys)
+                    )
+                );
+            }
+        }
+
+        return $tokenizedSettings;
+    }
+
+    /**
+     * Creates an anonymous function that acts as predicate.
+     *
+     * @param array   $requirements The array of conditions to satisfy.
+     * @param boolean $isRequired   Either these conditions are all required or all
+     * optional.
+     * @param boolean $atLeastOne   Indicates that at least one requirement must
+     * succeed.
+     *
+     * @return callable
+     */
+    protected static function getValidator(
+        array $requirements,
+        $isRequired,
+        $atLeastOne
+    ) {
+        // @codingStandardsIgnoreStart
+
+        return function ($userSettings) use ($requirements, $isRequired, $atLeastOne) {
+            $oneFound = false;
+            $result   = array_change_key_case($userSettings);
+            foreach ($requirements as $requirement) {
+                $settingName = strtolower($requirement[Resources::SETTING_NAME]);
+
+                // Check if the setting name exists in the provided user settings.
+                if (array_key_exists($settingName, $result)) {
+                    // Check if the provided user setting value is valid.
+                    $validationFunc = $requirement[Resources::SETTING_CONSTRAINT];
+                    $isValid        = $validationFunc($result[$settingName]);
+
+                    if ($isValid) {
+                        // Remove the setting as indicator for successful validation.
+                        unset($result[$settingName]);
+                        $oneFound = true;
+                    }
+                } else {
+                    // If required then fail because the setting does not exist
+                    if ($isRequired) {
+                        return null;
+                    }
+                }
+            }
+
+            if ($atLeastOne) {
+                // At least one requirement must succeed, otherwise fail.
+                return $oneFound ? $result : null;
+            } else {
+                return $result;
+            }
+        };
+
+        // @codingStandardsIgnoreEnd
+    }
+
+    /**
+     * Creates at lease one succeed predicate for the provided list of requirements.
+     *
+     * @return callable
+     */
+    protected static function atLeastOne()
+    {
+        $allSettings = func_get_args();
+        return self::getValidator($allSettings, false, true);
+    }
+
+    /**
+     * Creates an optional predicate for the provided list of requirements.
+     *
+     * @return callable
+     */
+    protected static function optional()
+    {
+        $optionalSettings = func_get_args();
+        return self::getValidator($optionalSettings, false, false);
+    }
+
+    /**
+     * Creates an required predicate for the provided list of requirements.
+     *
+     * @return callable
+     */
+    protected static function allRequired()
+    {
+        $requiredSettings = func_get_args();
+        return self::getValidator($requiredSettings, true, false);
+    }
+
+    /**
+     * Creates a setting value condition using the passed predicate.
+     *
+     * @param string   $name      The setting key name.
+     * @param callable $predicate The setting value predicate.
+     *
+     * @return array
+     */
+    protected static function settingWithFunc($name, $predicate)
+    {
+        $requirement                                = array();
+        $requirement[Resources::SETTING_NAME]       = $name;
+        $requirement[Resources::SETTING_CONSTRAINT] = $predicate;
+
+        return $requirement;
+    }
+
+    /**
+     * Creates a setting value condition that validates it is one of the
+     * passed valid values.
+     *
+     * @param string $name The setting key name.
+     *
+     * @return array
+     */
+    protected static function setting($name)
+    {
+        $validValues = func_get_args();
+
+        // Remove $name argument.
+        unset($validValues[0]);
+
+        $validValuesCount = func_num_args();
+
+        $predicate = function ($settingValue) use ($validValuesCount, $validValues) {
+            if (empty($validValues)) {
+                // No restrictions, succeed,
+                return true;
+            }
+
+            // Check to find if the $settingValue is valid or not. The index must
+            // start from 1 as unset deletes the value but does not update the array
+            // indecies.
+            for ($index = 1; $index < $validValuesCount; $index++) {
+                if ($settingValue == $validValues[$index]) {
+                    // $settingValue is found in valid values set, succeed.
+                    return true;
+                }
+            }
+
+            throw new \RuntimeException(
+                sprintf(
+                    Resources::INVALID_CONFIG_VALUE,
+                    $settingValue,
+                    implode("\n", $validValues)
+                )
+            );
+
+            // $settingValue is missing in valid values set, fail.
+            return false;
+        };
+
+        return self::settingWithFunc($name, $predicate);
+    }
+
+    /**
+     * Tests to see if a given list of settings matches a set of filters exactly.
+     *
+     * @param array $settings The settings to check.
+     *
+     * @return boolean If any filter returns null, false. If there are any settings
+     * left over after all filters are processed, false. Otherwise true.
+     */
+    protected static function matchedSpecification(array $settings)
+    {
+        $constraints = func_get_args();
+
+        // Remove first element which corresponds to $settings
+        unset($constraints[0]);
+
+        foreach ($constraints as $constraint) {
+            $remainingSettings = $constraint($settings);
+
+            if (is_null($remainingSettings)) {
+                return false;
+            } else {
+                $settings = $remainingSettings;
+            }
+        }
+
+        if (empty($settings)) {
+            return true;
+        }
+
+        return false;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/StorageServiceSettings.php

@@ -0,0 +1,713 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+/**
+ * Represents the settings used to sign and access a request against the storage
+ * service. For more information about storage service connection strings check this
+ * page: http://msdn.microsoft.com/en-us/library/ee758697
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class StorageServiceSettings extends ServiceSettings
+{
+    private $name;
+    private $key;
+    private $sas;
+    private $blobEndpointUri;
+    private $queueEndpointUri;
+    private $tableEndpointUri;
+    private $fileEndpointUri;
+    private $blobSecondaryEndpointUri;
+    private $queueSecondaryEndpointUri;
+    private $tableSecondaryEndpointUri;
+    private $fileSecondaryEndpointUri;
+
+    private static $devStoreAccount;
+    private static $useDevelopmentStorageSetting;
+    private static $developmentStorageProxyUriSetting;
+    private static $defaultEndpointsProtocolSetting;
+    private static $accountNameSetting;
+    private static $accountKeySetting;
+    private static $sasTokenSetting;
+    private static $blobEndpointSetting;
+    private static $queueEndpointSetting;
+    private static $tableEndpointSetting;
+    private static $fileEndpointSetting;
+    private static $endpointSuffixSetting;
+
+    /**
+     * If initialized or not
+     * @internal
+     */
+    protected static $isInitialized = false;
+
+    /**
+     * Valid setting keys
+     * @internal
+     */
+    protected static $validSettingKeys = array();
+
+    /**
+     * Initializes static members of the class.
+     *
+     * @return void
+     */
+    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,
+            // base64_decode will return false if the $key is not in base64 format.
+            function ($key) {
+                $isValidBase64String = base64_decode($key, true);
+                if ($isValidBase64String) {
+                    return true;
+                } else {
+                    throw new \RuntimeException(
+                        sprintf(Resources::INVALID_ACCOUNT_KEY_FORMAT, $key)
+                    );
+                }
+            }
+        );
+
+        self::$sasTokenSetting = self::setting(Resources::SAS_TOKEN_NAME);
+
+        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::$fileEndpointSetting = self::settingWithFunc(
+            Resources::FILE_ENDPOINT_NAME,
+            Validate::getIsValidUri()
+        );
+
+        self::$endpointSuffixSetting = self::settingWithFunc(
+            Resources::ENDPOINT_SUFFIX_NAME,
+            Validate::getIsValidHostname()
+        );
+
+        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::SAS_TOKEN_NAME;
+        self::$validSettingKeys[] = Resources::BLOB_ENDPOINT_NAME;
+        self::$validSettingKeys[] = Resources::QUEUE_ENDPOINT_NAME;
+        self::$validSettingKeys[] = Resources::TABLE_ENDPOINT_NAME;
+        self::$validSettingKeys[] = Resources::FILE_ENDPOINT_NAME;
+        self::$validSettingKeys[] = Resources::ENDPOINT_SUFFIX_NAME;
+    }
+
+    /**
+     * Creates new storage service settings instance.
+     *
+     * @param string $name                      The storage service name.
+     * @param string $key                       The storage service key.
+     * @param string $blobEndpointUri           The storage service blob
+     *                                          endpoint.
+     * @param string $queueEndpointUri          The storage service queue
+     *                                          endpoint.
+     * @param string $tableEndpointUri          The storage service table
+     *                                          endpoint.
+     * @param string $fileEndpointUri           The storage service file
+     *                                          endpoint.
+     * @param string $blobSecondaryEndpointUri  The storage service secondary
+     *                                          blob endpoint.
+     * @param string $queueSecondaryEndpointUri The storage service secondary
+     *                                          queue endpoint.
+     * @param string $tableSecondaryEndpointUri The storage service secondary
+     *                                          table endpoint.
+     * @param string $fileSecondaryEndpointUri  The storage service secondary
+     *                                          file endpoint.
+     * @param string $sas                       The storage service SAS token.
+     */
+    public function __construct(
+        $name,
+        $key,
+        $blobEndpointUri,
+        $queueEndpointUri,
+        $tableEndpointUri,
+        $fileEndpointUri,
+        $blobSecondaryEndpointUri = null,
+        $queueSecondaryEndpointUri = null,
+        $tableSecondaryEndpointUri = null,
+        $fileSecondaryEndpointUri = null,
+        $sas = null
+    ) {
+        $this->name                      = $name;
+        $this->key                       = $key;
+        $this->sas                       = $sas;
+        $this->blobEndpointUri           = $blobEndpointUri;
+        $this->queueEndpointUri          = $queueEndpointUri;
+        $this->tableEndpointUri          = $tableEndpointUri;
+        $this->fileEndpointUri           = $fileEndpointUri;
+        $this->blobSecondaryEndpointUri  = $blobSecondaryEndpointUri;
+        $this->queueSecondaryEndpointUri = $queueSecondaryEndpointUri;
+        $this->tableSecondaryEndpointUri = $tableSecondaryEndpointUri;
+        $this->fileSecondaryEndpointUri  = $fileSecondaryEndpointUri;
+    }
+
+    /**
+     * Returns a StorageServiceSettings with development storage credentials using
+     * the specified proxy Uri.
+     *
+     * @param string $proxyUri The proxy endpoint to use.
+     *
+     * @return StorageServiceSettings
+     */
+    private static function getDevelopmentStorageAccount($proxyUri)
+    {
+        if (is_null($proxyUri)) {
+            return self::developmentStorageAccount();
+        }
+
+        $scheme = parse_url($proxyUri, PHP_URL_SCHEME);
+        $host   = parse_url($proxyUri, PHP_URL_HOST);
+        $prefix = $scheme . "://" . $host;
+
+        return new StorageServiceSettings(
+            Resources::DEV_STORE_NAME,
+            Resources::DEV_STORE_KEY,
+            $prefix . ':10000/devstoreaccount1/',
+            $prefix . ':10001/devstoreaccount1/',
+            $prefix . ':10002/devstoreaccount1/',
+            null
+        );
+    }
+
+    /**
+     * Gets a StorageServiceSettings object that references the development storage
+     * account.
+     *
+     * @return StorageServiceSettings
+     */
+    public static function developmentStorageAccount()
+    {
+        if (is_null(self::$devStoreAccount)) {
+            self::$devStoreAccount = self::getDevelopmentStorageAccount(
+                Resources::DEV_STORE_URI
+            );
+        }
+
+        return self::$devStoreAccount;
+    }
+
+    /**
+     * Gets the default service endpoint using the specified protocol and account
+     * name.
+     *
+     * @param string $scheme      The scheme of the service end point.
+     * @param string $accountName The account name of the service.
+     * @param string $dnsPrefix   The service DNS prefix.
+     * @param string $dnsSuffix   The service DNS suffix.
+     * @param bool   $isSecondary If generating secondary endpoint.
+     *
+     * @return string
+     */
+    private static function getServiceEndpoint(
+        $scheme,
+        $accountName,
+        $dnsPrefix,
+        $dnsSuffix = null,
+        $isSecondary = false
+    ) {
+        if ($isSecondary) {
+            $accountName .= Resources::SECONDARY_STRING;
+        }
+        if ($dnsSuffix === null) {
+            $dnsSuffix = Resources::DEFAULT_ENDPOINT_SUFFIX;
+        }
+        return sprintf(
+            Resources::SERVICE_URI_FORMAT,
+            $scheme,
+            $accountName,
+            $dnsPrefix.$dnsSuffix
+        );
+    }
+
+    /**
+     * Creates StorageServiceSettings object given endpoints uri.
+     *
+     * @param array  $settings                  The service settings.
+     * @param string $blobEndpointUri           The blob endpoint uri.
+     * @param string $queueEndpointUri          The queue endpoint uri.
+     * @param string $tableEndpointUri          The table endpoint uri.
+     * @param string $fileEndpointUri           The file endpoint uri.
+     * @param string $blobSecondaryEndpointUri  The blob secondary endpoint uri.
+     * @param string $queueSecondaryEndpointUri The queue secondary endpoint uri.
+     * @param string $tableSecondaryEndpointUri The table secondary endpoint uri.
+     * @param string $fileSecondaryEndpointUri  The file secondary endpoint uri.
+     *
+     * @return StorageServiceSettings
+     */
+    private static function createStorageServiceSettings(
+        array $settings,
+        $blobEndpointUri = null,
+        $queueEndpointUri = null,
+        $tableEndpointUri = null,
+        $fileEndpointUri = null,
+        $blobSecondaryEndpointUri = null,
+        $queueSecondaryEndpointUri = null,
+        $tableSecondaryEndpointUri = null,
+        $fileSecondaryEndpointUri = null
+    ) {
+        $blobEndpointUri  = Utilities::tryGetValueInsensitive(
+            Resources::BLOB_ENDPOINT_NAME,
+            $settings,
+            $blobEndpointUri
+        );
+        $queueEndpointUri = Utilities::tryGetValueInsensitive(
+            Resources::QUEUE_ENDPOINT_NAME,
+            $settings,
+            $queueEndpointUri
+        );
+        $tableEndpointUri = Utilities::tryGetValueInsensitive(
+            Resources::TABLE_ENDPOINT_NAME,
+            $settings,
+            $tableEndpointUri
+        );
+        $fileEndpointUri = Utilities::tryGetValueInsensitive(
+            Resources::FILE_ENDPOINT_NAME,
+            $settings,
+            $fileEndpointUri
+        );
+        $accountName      = Utilities::tryGetValueInsensitive(
+            Resources::ACCOUNT_NAME_NAME,
+            $settings
+        );
+        $accountKey       = Utilities::tryGetValueInsensitive(
+            Resources::ACCOUNT_KEY_NAME,
+            $settings
+        );
+        $sasToken         = Utilities::tryGetValueInsensitive(
+            Resources::SAS_TOKEN_NAME,
+            $settings
+        );
+
+        return new StorageServiceSettings(
+            $accountName,
+            $accountKey,
+            $blobEndpointUri,
+            $queueEndpointUri,
+            $tableEndpointUri,
+            $fileEndpointUri,
+            $blobSecondaryEndpointUri,
+            $queueSecondaryEndpointUri,
+            $tableSecondaryEndpointUri,
+            $fileSecondaryEndpointUri,
+            $sasToken
+        );
+    }
+
+    /**
+     * Creates a StorageServiceSettings object from the given connection string.
+     *
+     * @param string $connectionString The storage settings connection string.
+     *
+     * @return StorageServiceSettings
+     */
+    public static function createFromConnectionString($connectionString)
+    {
+        $tokenizedSettings = self::parseAndValidateKeys($connectionString);
+
+        // Devstore case
+        $matchedSpecs = self::matchedSpecification(
+            $tokenizedSettings,
+            self::allRequired(self::$useDevelopmentStorageSetting),
+            self::optional(self::$developmentStorageProxyUriSetting)
+        );
+        if ($matchedSpecs) {
+            $proxyUri = Utilities::tryGetValueInsensitive(
+                Resources::DEVELOPMENT_STORAGE_PROXY_URI_NAME,
+                $tokenizedSettings
+            );
+
+            return self::getDevelopmentStorageAccount($proxyUri);
+        }
+
+        // Automatic case
+        $matchedSpecs = self::matchedSpecification(
+            $tokenizedSettings,
+            self::allRequired(
+                self::$defaultEndpointsProtocolSetting,
+                self::$accountNameSetting,
+                self::$accountKeySetting
+            ),
+            self::optional(
+                self::$blobEndpointSetting,
+                self::$queueEndpointSetting,
+                self::$tableEndpointSetting,
+                self::$fileEndpointSetting,
+                self::$endpointSuffixSetting
+            )
+        );
+        if ($matchedSpecs) {
+            $scheme         = Utilities::tryGetValueInsensitive(
+                Resources::DEFAULT_ENDPOINTS_PROTOCOL_NAME,
+                $tokenizedSettings
+            );
+            $accountName    = Utilities::tryGetValueInsensitive(
+                Resources::ACCOUNT_NAME_NAME,
+                $tokenizedSettings
+            );
+            $endpointSuffix = Utilities::tryGetValueInsensitive(
+                Resources::ENDPOINT_SUFFIX_NAME,
+                $tokenizedSettings
+            );
+            return self::createStorageServiceSettings(
+                $tokenizedSettings,
+                self::getServiceEndpoint(
+                    $scheme,
+                    $accountName,
+                    Resources::BLOB_DNS_PREFIX,
+                    $endpointSuffix
+                ),
+                self::getServiceEndpoint(
+                    $scheme,
+                    $accountName,
+                    Resources::QUEUE_DNS_PREFIX,
+                    $endpointSuffix
+                ),
+                self::getServiceEndpoint(
+                    $scheme,
+                    $accountName,
+                    Resources::TABLE_DNS_PREFIX,
+                    $endpointSuffix
+                ),
+                self::getServiceEndpoint(
+                    $scheme,
+                    $accountName,
+                    Resources::FILE_DNS_PREFIX,
+                    $endpointSuffix
+                ),
+                self::getServiceEndpoint(
+                    $scheme,
+                    $accountName,
+                    Resources::BLOB_DNS_PREFIX,
+                    $endpointSuffix,
+                    true
+                ),
+                self::getServiceEndpoint(
+                    $scheme,
+                    $accountName,
+                    Resources::QUEUE_DNS_PREFIX,
+                    $endpointSuffix,
+                    true
+                ),
+                self::getServiceEndpoint(
+                    $scheme,
+                    $accountName,
+                    Resources::TABLE_DNS_PREFIX,
+                    $endpointSuffix,
+                    true
+                ),
+                self::getServiceEndpoint(
+                    $scheme,
+                    $accountName,
+                    Resources::FILE_DNS_PREFIX,
+                    $endpointSuffix,
+                    true
+                )
+            );
+        }
+
+        // Explicit case for AccountName/AccountKey combination
+        $matchedSpecs = self::matchedSpecification(
+            $tokenizedSettings,
+            self::atLeastOne(
+                self::$blobEndpointSetting,
+                self::$queueEndpointSetting,
+                self::$tableEndpointSetting,
+                self::$fileEndpointSetting
+            ),
+            self::allRequired(
+                self::$accountNameSetting,
+                self::$accountKeySetting
+            )
+        );
+        if ($matchedSpecs) {
+            return self::createStorageServiceSettings($tokenizedSettings);
+        }
+
+        // Explicit case for SAS token
+        $matchedSpecs = self::matchedSpecification(
+            $tokenizedSettings,
+            self::atLeastOne(
+                self::$blobEndpointSetting,
+                self::$queueEndpointSetting,
+                self::$tableEndpointSetting,
+                self::$fileEndpointSetting
+            ),
+            self::allRequired(
+                self::$sasTokenSetting
+            )
+        );
+        if ($matchedSpecs) {
+            return self::createStorageServiceSettings($tokenizedSettings);
+        }
+
+        self::noMatch($connectionString);
+    }
+
+    /**
+     * Creates a StorageServiceSettings object from the given connection string.
+     * Note this is only for AAD connection string, it should at least contain
+     * the account name.
+     *
+     * @param string $connectionString The storage settings connection string.
+     *
+     * @return StorageServiceSettings
+     */
+    public static function createFromConnectionStringForTokenCredential($connectionString)
+    {
+        // Explicit case for AAD token, Connection string could only have account
+        // name.
+        $tokenizedSettings = self::parseAndValidateKeys($connectionString);
+
+        $scheme         = Utilities::tryGetValueInsensitive(
+            Resources::DEFAULT_ENDPOINTS_PROTOCOL_NAME,
+            $tokenizedSettings
+        );
+        $accountName    = Utilities::tryGetValueInsensitive(
+            Resources::ACCOUNT_NAME_NAME,
+            $tokenizedSettings
+        );
+        $endpointSuffix = Utilities::tryGetValueInsensitive(
+            Resources::ENDPOINT_SUFFIX_NAME,
+            $tokenizedSettings
+        );
+        return self::createStorageServiceSettings(
+            $tokenizedSettings,
+            self::getServiceEndpoint(
+                $scheme,
+                $accountName,
+                Resources::BLOB_DNS_PREFIX,
+                $endpointSuffix
+            ),
+            self::getServiceEndpoint(
+                $scheme,
+                $accountName,
+                Resources::QUEUE_DNS_PREFIX,
+                $endpointSuffix
+            ),
+            self::getServiceEndpoint(
+                $scheme,
+                $accountName,
+                Resources::TABLE_DNS_PREFIX,
+                $endpointSuffix
+            ),
+            self::getServiceEndpoint(
+                $scheme,
+                $accountName,
+                Resources::FILE_DNS_PREFIX,
+                $endpointSuffix
+            ),
+            self::getServiceEndpoint(
+                $scheme,
+                $accountName,
+                Resources::BLOB_DNS_PREFIX,
+                $endpointSuffix,
+                true
+            ),
+            self::getServiceEndpoint(
+                $scheme,
+                $accountName,
+                Resources::QUEUE_DNS_PREFIX,
+                $endpointSuffix,
+                true
+            ),
+            self::getServiceEndpoint(
+                $scheme,
+                $accountName,
+                Resources::TABLE_DNS_PREFIX,
+                $endpointSuffix,
+                true
+            ),
+            self::getServiceEndpoint(
+                $scheme,
+                $accountName,
+                Resources::FILE_DNS_PREFIX,
+                $endpointSuffix,
+                true
+            )
+        );
+    }
+
+    /**
+     * Gets storage service name.
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Gets storage service key.
+     *
+     * @return string
+     */
+    public function getKey()
+    {
+        return $this->key;
+    }
+
+    /**
+     * Checks if there is a SAS token.
+     *
+     * @return boolean
+     */
+    public function hasSasToken()
+    {
+        return !empty($this->sas);
+    }
+
+    /**
+     * Gets storage service SAS token.
+     *
+     * @return string
+     */
+    public function getSasToken()
+    {
+        return $this->sas;
+    }
+
+    /**
+     * Gets storage service blob endpoint uri.
+     *
+     * @return string
+     */
+    public function getBlobEndpointUri()
+    {
+        return $this->blobEndpointUri;
+    }
+
+    /**
+     * Gets storage service queue endpoint uri.
+     *
+     * @return string
+     */
+    public function getQueueEndpointUri()
+    {
+        return $this->queueEndpointUri;
+    }
+
+    /**
+     * Gets storage service table endpoint uri.
+     *
+     * @return string
+     */
+    public function getTableEndpointUri()
+    {
+        return $this->tableEndpointUri;
+    }
+
+    /**
+     * Gets storage service file endpoint uri.
+     *
+     * @return string
+     */
+    public function getFileEndpointUri()
+    {
+        return $this->fileEndpointUri;
+    }
+
+    /**
+     * Gets storage service secondary blob endpoint uri.
+     *
+     * @return string
+     */
+    public function getBlobSecondaryEndpointUri()
+    {
+        return $this->blobSecondaryEndpointUri;
+    }
+
+    /**
+     * Gets storage service secondary queue endpoint uri.
+     *
+     * @return string
+     */
+    public function getQueueSecondaryEndpointUri()
+    {
+        return $this->queueSecondaryEndpointUri;
+    }
+
+    /**
+     * Gets storage service secondary table endpoint uri.
+     *
+     * @return string
+     */
+    public function getTableSecondaryEndpointUri()
+    {
+        return $this->tableSecondaryEndpointUri;
+    }
+
+    /**
+     * Gets storage service secondary file endpoint uri.
+     *
+     * @return string
+     */
+    public function getFileSecondaryEndpointUri()
+    {
+        return $this->fileSecondaryEndpointUri;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Utilities.php

@@ -0,0 +1,907 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * Utilities for the project
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class Utilities
+{
+    /**
+     * Returns the specified value of the $key passed from $array and in case that
+     * this $key doesn't exist, the default value is returned.
+     *
+     * @param array $array   The array to be used.
+     * @param mixed $key     The array key.
+     * @param mixed $default The value to return if $key is not found in $array.
+     *
+     * @return mixed
+     */
+    public static function tryGetValue($array, $key, $default = null)
+    {
+        return (!is_null($array)) && is_array($array) && array_key_exists($key, $array)
+            ? $array[$key]
+            : $default;
+    }
+
+    /**
+     * Adds a url scheme if there is no scheme. Return null if input URL is null.
+     *
+     * @param string $url    The URL.
+     * @param string $scheme The scheme. By default HTTP
+     *
+     * @return string
+     */
+    public static function tryAddUrlScheme($url, $scheme = 'http')
+    {
+        if ($url == null) {
+            return $url;
+        }
+
+        $urlScheme = parse_url($url, PHP_URL_SCHEME);
+
+        if (empty($urlScheme)) {
+            $url = "$scheme://" . $url;
+        }
+
+        return $url;
+    }
+
+    /**
+     * Parse storage account name from an endpoint url.
+     *
+     * @param string $url The endpoint $url
+     *
+     * @return string
+     */
+    public static function tryParseAccountNameFromUrl($url)
+    {
+        $host = parse_url($url, PHP_URL_HOST);
+
+        // first token of the url host is account name
+        return explode('.', $host)[0];
+    }
+
+    /**
+     * Parse secondary endpoint url string from a primary endpoint url.
+     *
+     * Return null if the primary endpoint url is invalid.
+     *
+     * @param string $uri The primary endpoint url string.
+     *
+     * @return null|string
+     */
+    public static function tryGetSecondaryEndpointFromPrimaryEndpoint($uri)
+    {
+        $splitTokens = explode('.', $uri);
+        if (count($splitTokens) > 0 && $splitTokens[0] != '') {
+            $schemaAccountToken = $splitTokens[0];
+            $schemaAccountSplitTokens = explode('/', $schemaAccountToken);
+            if (count($schemaAccountSplitTokens) > 0 &&
+                $schemaAccountSplitTokens[0] != '') {
+                $accountName = $schemaAccountSplitTokens[
+                    count($schemaAccountSplitTokens) - 1
+                ];
+                $schemaAccountSplitTokens[count($schemaAccountSplitTokens) - 1] =
+                    $accountName . Resources::SECONDARY_STRING;
+
+                $splitTokens[0] = implode('/', $schemaAccountSplitTokens);
+                $secondaryUri = implode('.', $splitTokens);
+                return $secondaryUri;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * tries to get nested array with index name $key from $array.
+     *
+     * Returns empty array object if the value is NULL.
+     *
+     * @param string $key   The index name.
+     * @param array  $array The array object.
+     *
+     * @return array
+     */
+    public static function tryGetArray($key, array $array)
+    {
+        return Utilities::getArray(Utilities::tryGetValue($array, $key));
+    }
+
+    /**
+     * Adds the given key/value pair into array if the value doesn't satisfy empty().
+     *
+     * This function just validates that the given $array is actually array. If it's
+     * NULL the function treats it as array.
+     *
+     * @param string $key    The key.
+     * @param string $value  The value.
+     * @param array  &$array The array. If NULL will be used as array.
+     *
+     * @return void
+     */
+    public static function addIfNotEmpty($key, $value, array &$array)
+    {
+        if (!is_null($array)) {
+            Validate::isArray($array, 'array');
+        }
+
+        if (!empty($value)) {
+            $array[$key] = $value;
+        }
+    }
+
+    /**
+     * Returns the specified value of the key chain passed from $array and in case
+     * that key chain doesn't exist, null is returned.
+     *
+     * @param array $array Array to be used.
+     *
+     * @return mixed
+     */
+    public static function tryGetKeysChainValue(array $array)
+    {
+        $arguments    = func_get_args();
+        $numArguments = func_num_args();
+
+        $currentArray = $array;
+        for ($i = 1; $i < $numArguments; $i++) {
+            if (is_array($currentArray)) {
+                if (array_key_exists($arguments[$i], $currentArray)) {
+                    $currentArray = $currentArray[$arguments[$i]];
+                } else {
+                    return null;
+                }
+            } else {
+                return null;
+            }
+        }
+
+        return $currentArray;
+    }
+
+    /**
+     * Checks if the passed $string starts with $prefix
+     *
+     * @param string  $string     word to seaech in
+     * @param string  $prefix     prefix to be matched
+     * @param boolean $ignoreCase true to ignore case during the comparison;
+     * otherwise, false
+     *
+     * @return boolean
+     */
+    public static function startsWith($string, $prefix, $ignoreCase = false)
+    {
+        if ($ignoreCase) {
+            $string = strtolower($string);
+            $prefix = strtolower($prefix);
+        }
+        return ($prefix == substr($string, 0, strlen($prefix)));
+    }
+
+    /**
+     * Returns grouped items from passed $var
+     *
+     * @param array $var item to group
+     *
+     * @return array
+     */
+    public static function getArray(array $var)
+    {
+        if (is_null($var) || empty($var)) {
+            return array();
+        }
+
+        foreach ($var as $value) {
+            if ((gettype($value) == 'object')
+                && (get_class($value) == 'SimpleXMLElement')
+            ) {
+                return (array) $var;
+            } elseif (!is_array($value)) {
+                return array($var);
+            }
+        }
+
+        return $var;
+    }
+
+    /**
+     * Unserializes the passed $xml into array.
+     *
+     * @param string $xml XML to be parsed.
+     *
+     * @return array
+     */
+    public static function unserialize($xml)
+    {
+        $sxml = new \SimpleXMLElement($xml);
+
+        return self::_sxml2arr($sxml);
+    }
+
+    /**
+     * Converts a SimpleXML object to an Array recursively
+     * ensuring all sub-elements are arrays as well.
+     *
+     * @param string $sxml SimpleXML object
+     * @param array  $arr  Array into which to store results
+     *
+     * @return array
+     */
+    private static function _sxml2arr($sxml, array $arr = null)
+    {
+        foreach ((array) $sxml as $key => $value) {
+            if (is_object($value) || (is_array($value))) {
+                $arr[$key] = self::_sxml2arr($value);
+            } else {
+                $arr[$key] = $value;
+            }
+        }
+
+        return $arr;
+    }
+
+    /**
+     * Serializes given array into xml. The array indices must be string to use
+     * them as XML tags.
+     *
+     * @param array  $array      object to serialize represented in array.
+     * @param string $rootName   name of the XML root element.
+     * @param string $defaultTag default tag for non-tagged elements.
+     * @param string $standalone adds 'standalone' header tag, values 'yes'/'no'
+     *
+     * @return string
+     */
+    public static function serialize(
+        array $array,
+        $rootName,
+        $defaultTag = null,
+        $standalone = null
+    ) {
+        $xmlVersion  = '1.0';
+        $xmlEncoding = 'UTF-8';
+
+        if (!is_array($array)) {
+            return false;
+        }
+
+        $xmlw = new \XmlWriter();
+        $xmlw->openMemory();
+        $xmlw->startDocument($xmlVersion, $xmlEncoding, $standalone);
+
+        $xmlw->startElement($rootName);
+
+        self::_arr2xml($xmlw, $array, $defaultTag);
+
+        $xmlw->endElement();
+
+        return $xmlw->outputMemory(true);
+    }
+
+    /**
+     * Takes an array and produces XML based on it.
+     *
+     * @param XMLWriter $xmlw       XMLWriter object that was previously instanted
+     * and is used for creating the XML.
+     * @param array     $data       Array to be converted to XML
+     * @param string    $defaultTag Default XML tag to be used if none specified.
+     *
+     * @return void
+     */
+    private static function _arr2xml(
+        \XMLWriter $xmlw,
+        array $data,
+        $defaultTag = null
+    ) {
+        foreach ($data as $key => $value) {
+            if (strcmp($key, '@attributes') == 0) {
+                foreach ($value as $attributeName => $attributeValue) {
+                    $xmlw->writeAttribute($attributeName, $attributeValue);
+                }
+            } elseif (is_array($value)) {
+                if (!is_int($key)) {
+                    if ($key != Resources::EMPTY_STRING) {
+                        $xmlw->startElement($key);
+                    } else {
+                        $xmlw->startElement($defaultTag);
+                    }
+                }
+
+                self::_arr2xml($xmlw, $value);
+
+                if (!is_int($key)) {
+                    $xmlw->endElement();
+                }
+                continue;
+            } else {
+                $xmlw->writeElement($key, $value);
+            }
+        }
+    }
+
+    /**
+     * Converts string into boolean value.
+     *
+     * @param string $obj       boolean value in string format.
+     * @param bool   $skipNull  If $skipNull is set, will return NULL directly
+     *                          when $obj is NULL.
+     *
+     * @return bool
+     */
+    public static function toBoolean($obj, $skipNull = false)
+    {
+        if ($skipNull && is_null($obj)) {
+            return null;
+        }
+
+        return filter_var($obj, FILTER_VALIDATE_BOOLEAN);
+    }
+
+    /**
+     * Converts string into boolean value.
+     *
+     * @param bool $obj boolean value to convert.
+     *
+     * @return string
+     */
+    public static function booleanToString($obj)
+    {
+        return $obj ? 'true' : 'false';
+    }
+
+    /**
+     * Converts a given date string into \DateTime object
+     *
+     * @param string $date windows azure date ins string representation.
+     *
+     * @return \DateTime
+     */
+    public static function rfc1123ToDateTime($date)
+    {
+        $timeZone = new \DateTimeZone('GMT');
+        $format   = Resources::AZURE_DATE_FORMAT;
+
+        return \DateTime::createFromFormat($format, $date, $timeZone);
+    }
+
+    /**
+     * Generate ISO 8601 compliant date string in UTC time zone
+     *
+     * @param \DateTimeInterface $date The date value to convert
+     *
+     * @return string
+     */
+    public static function isoDate(\DateTimeInterface $date)
+    {
+        $date = clone $date;
+        $date = $date->setTimezone(new \DateTimeZone('UTC'));
+
+        return str_replace('+00:00', 'Z', $date->format('c'));
+    }
+
+    /**
+     * Converts a DateTime object into an Edm.DaeTime value in UTC timezone,
+     * represented as a string.
+     *
+     * @param mixed $value The datetime value.
+     *
+     * @return string
+     */
+    public static function convertToEdmDateTime($value)
+    {
+        if (empty($value)) {
+            return $value;
+        }
+
+        if (is_string($value)) {
+            $value =  self::convertToDateTime($value);
+        }
+
+        Validate::isDate($value);
+
+        $cloned = clone $value;
+        $cloned->setTimezone(new \DateTimeZone('UTC'));
+        return str_replace('+00:00', 'Z', $cloned->format("Y-m-d\TH:i:s.u0P"));
+    }
+
+    /**
+     * Converts a string to a \DateTime object. Returns false on failure.
+     *
+     * @param string $value The string value to parse.
+     *
+     * @return \DateTime
+     */
+    public static function convertToDateTime($value)
+    {
+        if ($value instanceof \DateTime) {
+            return $value;
+        }
+
+        if (substr($value, -1) == 'Z') {
+            $value = substr($value, 0, strlen($value) - 1);
+        }
+
+        return new \DateTime($value, new \DateTimeZone('UTC'));
+    }
+
+    /**
+     * Converts string to stream handle.
+     *
+     * @param string $string The string contents.
+     *
+     * @return resource
+     */
+    public static function stringToStream($string)
+    {
+        return fopen('data://text/plain,' . urlencode($string), 'rb');
+    }
+
+    /**
+     * Sorts an array based on given keys order.
+     *
+     * @param array $array The array to sort.
+     * @param array $order The keys order array.
+     *
+     * @return array
+     */
+    public static function orderArray(array $array, array $order)
+    {
+        $ordered = array();
+
+        foreach ($order as $key) {
+            if (array_key_exists($key, $array)) {
+                $ordered[$key] = $array[$key];
+            }
+        }
+
+        return $ordered;
+    }
+
+    /**
+     * Checks if a value exists in an array. The comparison is done in a case
+     * insensitive manner.
+     *
+     * @param string $needle   The searched value.
+     * @param array  $haystack The array.
+     *
+     * @return boolean
+     */
+    public static function inArrayInsensitive($needle, array $haystack)
+    {
+        return in_array(strtolower($needle), array_map('strtolower', $haystack));
+    }
+
+    /**
+     * Checks if the given key exists in the array. The comparison is done in a case
+     * insensitive manner.
+     *
+     * @param string $key    The value to check.
+     * @param array  $search The array with keys to check.
+     *
+     * @return boolean
+     */
+    public static function arrayKeyExistsInsensitive($key, array $search)
+    {
+        return array_key_exists(strtolower($key), array_change_key_case($search));
+    }
+
+    /**
+     * Returns the specified value of the $key passed from $array and in case that
+     * this $key doesn't exist, the default value is returned. The key matching is
+     * done in a case insensitive manner.
+     *
+     * @param string $key      The array key.
+     * @param array  $haystack The array to be used.
+     * @param mixed  $default  The value to return if $key is not found in $array.
+     *
+     * @return mixed
+     */
+    public static function tryGetValueInsensitive($key, $haystack, $default = null)
+    {
+        $array = array_change_key_case($haystack);
+        return Utilities::tryGetValue($array, strtolower($key), $default);
+    }
+
+    /**
+     * Returns a string representation of a version 4 GUID, which uses random
+     * numbers.There are 6 reserved bits, and the GUIDs have this format:
+     *     xxxxxxxx-xxxx-4xxx-[8|9|a|b]xxx-xxxxxxxxxxxx
+     * where 'x' is a hexadecimal digit, 0-9a-f.
+     *
+     * See http://tools.ietf.org/html/rfc4122 for more information.
+     *
+     * Note: This function is available on all platforms, while the
+     * com_create_guid() is only available for Windows.
+     *
+     * @return string A new GUID.
+     */
+    public static function getGuid()
+    {
+        // @codingStandardsIgnoreStart
+
+        return sprintf(
+            '%04x%04x-%04x-%04x-%02x%02x-%04x%04x%04x',
+            mt_rand(0, 65535),
+            mt_rand(0, 65535),          // 32 bits for "time_low"
+            mt_rand(0, 65535),          // 16 bits for "time_mid"
+            mt_rand(0, 4096) + 16384,   // 16 bits for "time_hi_and_version", with
+                                        // the most significant 4 bits being 0100
+                                        // to indicate randomly generated version
+            mt_rand(0, 64) + 128,       // 8 bits  for "clock_seq_hi", with
+                                        // the most significant 2 bits being 10,
+                                        // required by version 4 GUIDs.
+            mt_rand(0, 255),            // 8 bits  for "clock_seq_low"
+            mt_rand(0, 65535),          // 16 bits for "node 0" and "node 1"
+            mt_rand(0, 65535),          // 16 bits for "node 2" and "node 3"
+            mt_rand(0, 65535)           // 16 bits for "node 4" and "node 5"
+        );
+
+        // @codingStandardsIgnoreEnd
+    }
+
+    /**
+     * Creates a list of objects of type $class from the provided array using static
+     * create method.
+     *
+     * @param array  $parsed The object in array representation
+     * @param string $class  The class name. Must have static method create.
+     *
+     * @return array
+     */
+    public static function createInstanceList(array $parsed, $class)
+    {
+        $list = array();
+
+        foreach ($parsed as $value) {
+            $list[] = $class::create($value);
+        }
+
+        return $list;
+    }
+
+    /**
+     * Takes a string and return if it ends with the specified character/string.
+     *
+     * @param string  $haystack   The string to search in.
+     * @param string  $needle     postfix to match.
+     * @param boolean $ignoreCase Set true to ignore case during the comparison;
+     * otherwise, false
+     *
+     * @return boolean
+     */
+    public static function endsWith($haystack, $needle, $ignoreCase = false)
+    {
+        if ($ignoreCase) {
+            $haystack = strtolower($haystack);
+            $needle   = strtolower($needle);
+        }
+        $length = strlen($needle);
+        if ($length == 0) {
+            return true;
+        }
+
+        return (substr($haystack, -$length) === $needle);
+    }
+
+    /**
+     * Get id from entity object or string.
+     * If entity is object than validate type and return $entity->$method()
+     * If entity is string than return this string
+     *
+     * @param object|string $entity Entity with id property
+     * @param string        $type   Entity type to validate
+     * @param string        $method Methods that gets id (getId by default)
+     *
+     * @return string
+     */
+    public static function getEntityId($entity, $type, $method = 'getId')
+    {
+        if (is_string($entity)) {
+            return $entity;
+        } else {
+            Validate::isA($entity, $type, 'entity');
+            Validate::methodExists($entity, $method, $type);
+
+            return $entity->$method();
+        }
+    }
+
+    /**
+     * Generate a pseudo-random string of bytes using a cryptographically strong
+     * algorithm.
+     *
+     * @param int $length Length of the string in bytes
+     *
+     * @return string|boolean Generated string of bytes on success, or FALSE on
+     *                        failure.
+     */
+    public static function generateCryptoKey($length)
+    {
+        return openssl_random_pseudo_bytes($length);
+    }
+
+    /**
+     * Convert base 256 number to decimal number.
+     *
+     * @param string $number Base 256 number
+     *
+     * @return string Decimal number
+     */
+    public static function base256ToDec($number)
+    {
+        Validate::canCastAsString($number, 'number');
+
+        $result = 0;
+        $base   = 1;
+        for ($i = strlen($number) - 1; $i >= 0; $i--) {
+            $result = bcadd($result, bcmul(ord($number[$i]), $base));
+            $base   = bcmul($base, 256);
+        }
+
+        return $result;
+    }
+
+    /**
+     * To evaluate if the stream is larger than a certain size. To restore
+     * the stream, it has to be seekable, so will return true if the stream
+     * is not seekable.
+     * @param  StreamInterface $stream The stream to be evaluated.
+     * @param  int             $size   The size if the string is larger than.
+     *
+     * @return boolean         true if the stream is larger than the given size.
+     */
+    public static function isStreamLargerThanSizeOrNotSeekable(StreamInterface $stream, $size)
+    {
+        Validate::isInteger($size, 'size');
+        Validate::isTrue(
+            $stream instanceof StreamInterface,
+            sprintf(Resources::INVALID_PARAM_MSG, 'stream', 'Psr\Http\Message\StreamInterface')
+        );
+        $result = true;
+        if ($stream->isSeekable()) {
+            $position = $stream->tell();
+            try {
+                $stream->seek($size);
+            } catch (\RuntimeException $e) {
+                $pos = strpos(
+                    $e->getMessage(),
+                    'to seek to stream position '
+                );
+                if ($pos == null) {
+                    throw $e;
+                }
+                $result = false;
+            }
+            if ($stream->eof()) {
+                $result = false;
+            } elseif ($stream->read(1) == '') {
+                $result = false;
+            }
+            $stream->seek($position);
+        }
+        return $result;
+    }
+
+    /**
+     * Gets metadata array by parsing them from given headers.
+     *
+     * @param array $headers HTTP headers containing metadata elements.
+     *
+     * @return array
+     */
+    public static function getMetadataArray(array $headers)
+    {
+        $metadata = array();
+        foreach ($headers as $key => $value) {
+            $isMetadataHeader = Utilities::startsWith(
+                strtolower($key),
+                Resources::X_MS_META_HEADER_PREFIX
+            );
+
+            if ($isMetadataHeader) {
+                // Metadata name is case-presrved and case insensitive
+                $MetadataName = str_ireplace(
+                    Resources::X_MS_META_HEADER_PREFIX,
+                    Resources::EMPTY_STRING,
+                    $key
+                );
+                $metadata[$MetadataName] = $value;
+            }
+        }
+
+        return $metadata;
+    }
+
+    /**
+     * Validates the provided metadata array.
+     *
+     * @param array $metadata The metadata array.
+     *
+     * @return void
+     */
+    public static function validateMetadata(array $metadata = null)
+    {
+        if (!is_null($metadata)) {
+            Validate::isArray($metadata, 'metadata');
+        } else {
+            $metadata = array();
+        }
+
+        foreach ($metadata as $key => $value) {
+            Validate::canCastAsString($key, 'metadata key');
+            Validate::canCastAsString($value, 'metadata value');
+        }
+    }
+
+    /**
+     * Append the content to file.
+     * @param  string $path    The file to append to.
+     * @param  string $content The content to append.
+     *
+     * @return void
+     */
+    public static function appendToFile($path, $content)
+    {
+        $resource = @fopen($path, 'a+');
+        if ($resource != null) {
+            fwrite($resource, $content);
+            fclose($resource);
+        }
+    }
+
+    /**
+     * Check if all the bytes are zero.
+     *
+     * @param string $content The content.
+     * @return bool
+     */
+    public static function allZero($content)
+    {
+        $size = strlen($content);
+
+        // If all Zero, skip this range
+        for ($i = 0; $i < $size; $i++) {
+            if (ord($content[$i]) != 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Append the delimiter to the string. The delimiter will not be added if
+     * the string already ends with this delimiter.
+     *
+     * @param string $string    The string to add delimiter to.
+     * @param string $delimiter The delimiter to be added.
+     *
+     * @return string
+     */
+    public static function appendDelimiter($string, $delimiter)
+    {
+        if (!self::endsWith($string, $delimiter)) {
+            $string .= $delimiter;
+        }
+
+        return $string;
+    }
+
+    /**
+     * Static function used to determine if the request is performed against
+     * secondary endpoint.
+     *
+     * @param  Psr\Http\Message\RequestInterface $request The request performed.
+     * @param  array                             $options The options of the
+     *                                                    request. Must contain
+     *                                                    Resources::ROS_SECONDARY_URI
+     *
+     * @return boolean
+     */
+    public static function requestSentToSecondary(
+        \Psr\Http\Message\RequestInterface $request,
+        array $options
+    ) {
+        $uri = $request->getUri();
+        $secondaryUri = $options[Resources::ROS_SECONDARY_URI];
+        $isSecondary = false;
+        if (strpos((string)$uri, (string)$secondaryUri) !== false) {
+            $isSecondary = true;
+        }
+        return $isSecondary;
+    }
+
+    /**
+     * Gets the location value from the headers.
+     *
+     * @param  array  $headers request/response headers.
+     *
+     * @return string
+     */
+    public static function getLocationFromHeaders(array $headers)
+    {
+        $value = Utilities::tryGetValue(
+            $headers,
+            Resources::X_MS_CONTINUATION_LOCATION_MODE
+        );
+
+        $result = '';
+        if (\is_string($value)) {
+            $result = $value;
+        } elseif (!empty($value)) {
+            $result = $value[0];
+        }
+        return $result;
+    }
+
+    /**
+     * Gets if the value is a double value or string representation of a double
+     * value
+     *
+     * @param  mixed  $value The value to be verified.
+     *
+     * @return boolean
+     */
+    public static function isDouble($value)
+    {
+        return is_numeric($value) && is_double($value + 0);
+    }
+
+    /**
+     * Calculates the content MD5 which is base64 encoded. This should be align
+     * with the server calculated MD5.
+     *
+     * @param  string $content the content to be calculated.
+     *
+     * @return string
+     */
+    public static function calculateContentMD5($content)
+    {
+        Validate::notNull($content, 'content');
+        Validate::canCastAsString($content, 'content');
+
+        return base64_encode(md5($content, true));
+    }
+
+    /**
+     * Return if the environment is in 64 bit PHP.
+     *
+     * @return bool
+     */
+    public static function is64BitPHP()
+    {
+        return PHP_INT_SIZE == 8;
+    }
+}

3rdparty/microsoft/azure-storage-common/src/Common/Internal/Validate.php

@@ -0,0 +1,461 @@
+<?php
+
+/**
+ * LICENSE: The MIT License (the "License")
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * https://github.com/azure/azure-storage-php/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ * PHP version 5
+ *
+ * @ignore
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+
+namespace MicrosoftAzure\Storage\Common\Internal;
+
+use MicrosoftAzure\Storage\Common\Exceptions\InvalidArgumentTypeException;
+
+/**
+ * Validates against a condition and throws an exception in case of failure.
+ *
+ * @category  Microsoft
+ * @package   MicrosoftAzure\Storage\Common\Internal
+ * @author    Azure Storage PHP SDK <dmsh@microsoft.com>
+ * @copyright 2016 Microsoft Corporation
+ * @license   https://github.com/azure/azure-storage-php/LICENSE
+ * @link      https://github.com/azure/azure-storage-php
+ */
+class Validate
+{
+    /**
+     * Throws exception if the provided variable type is not array.
+     *
+     * @param mixed  $var  The variable to check.
+     * @param string $name The parameter name.
+     *
+     * @throws InvalidArgumentTypeException.
+     *
+     * @return void
+     */
+    public static function isArray($var, $name)
+    {
+        if (!is_array($var)) {
+            throw new InvalidArgumentTypeException(gettype(array()), $name);
+        }
+    }
+
+    /**
+     * Throws exception if the provided variable can not convert to a string.
+     *
+     * @param mixed  $var  The variable to check.
+     * @param string $name The parameter name.
+     *
+     * @throws InvalidArgumentTypeException
+     *
+     * @return void
+     */
+    public static function canCastAsString($var, $name)
+    {
+        try {
+            (string)$var;
+        } catch (\Exception $e) {
+            throw new InvalidArgumentTypeException(gettype(''), $name);
+        }
+    }
+
+    /**
+     * Throws exception if the provided variable type is not boolean.
+     *
+     * @param mixed $var variable to check against.
+     *
+     * @throws InvalidArgumentTypeException
+     *
+     * @return void
+     */
+    public static function isBoolean($var)
+    {
+        (bool)$var;
+    }
+
+    /**
+     * Throws exception if the provided variable is set to null.
+     *
+     * @param mixed  $var  The variable to check.
+     * @param string $name The parameter name.
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public static function notNullOrEmpty($var, $name)
+    {
+        if (is_null($var) || (empty($var) && $var != '0')) {
+            throw new \InvalidArgumentException(
+                sprintf(Resources::NULL_OR_EMPTY_MSG, $name)
+            );
+        }
+    }
+
+    /**
+     * Throws exception if the provided variable is not double.
+     *
+     * @param mixed  $var  The variable to check.
+     * @param string $name The parameter name.
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public static function isDouble($var, $name)
+    {
+        if (!is_numeric($var)) {
+            throw new InvalidArgumentTypeException('double', $name);
+        }
+    }
+
+    /**
+     * Throws exception if the provided variable type is not integer.
+     *
+     * @param mixed  $var  The variable to check.
+     * @param string $name The parameter name.
+     *
+     * @throws InvalidArgumentTypeException
+     *
+     * @return void
+     */
+    public static function isInteger($var, $name)
+    {
+        try {
+            (int)$var;
+        } catch (\Exception $e) {
+            throw new InvalidArgumentTypeException(gettype(123), $name);
+        }
+    }
+
+    /**
+     * Returns whether the variable is an empty or null string.
+     *
+     * @param string $var value.
+     *
+     * @return boolean
+     */
+    public static function isNullOrEmptyString($var)
+    {
+        try {
+            (string)$var;
+        } catch (\Exception $e) {
+            return false;
+        }
+
+        return (!isset($var) || trim($var)==='');
+    }
+
+    /**
+     * Throws exception if the provided condition is not satisfied.
+     *
+     * @param bool   $isSatisfied    condition result.
+     * @param string $failureMessage the exception message
+     *
+     * @throws \Exception
+     *
+     * @return void
+     */
+    public static function isTrue($isSatisfied, $failureMessage)
+    {
+        if (!$isSatisfied) {
+            throw new \InvalidArgumentException($failureMessage);
+        }
+    }
+
+    /**
+     * Throws exception if the provided $date doesn't implement \DateTimeInterface
+     *
+     * @param mixed $date variable to check against.
+     *
+     * @throws InvalidArgumentTypeException
+     *
+     * @return void
+     */
+    public static function isDate($date)
+    {
+        if (gettype($date) != 'object' || !($date instanceof \DateTimeInterface)) {
+            throw new InvalidArgumentTypeException('DateTimeInterface');
+        }
+    }
+
+    /**
+     * Throws exception if the provided variable is set to null.
+     *
+     * @param mixed  $var  The variable to check.
+     * @param string $name The parameter name.
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public static function notNull($var, $name)
+    {
+        if (is_null($var)) {
+            throw new \InvalidArgumentException(sprintf(Resources::NULL_MSG, $name));
+        }
+    }
+
+    /**
+     * Throws exception if the object is not of the specified class type.
+     *
+     * @param mixed  $objectInstance An object that requires class type validation.
+     * @param mixed  $classInstance  The instance of the class the the
+     * object instance should be.
+     * @param string $name           The name of the object.
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public static function isInstanceOf($objectInstance, $classInstance, $name)
+    {
+        Validate::notNull($classInstance, 'classInstance');
+        if (is_null($objectInstance)) {
+            return true;
+        }
+
+        $objectType = gettype($objectInstance);
+        $classType  = gettype($classInstance);
+
+        if ($objectType === $classType) {
+            return true;
+        } else {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    Resources::INSTANCE_TYPE_VALIDATION_MSG,
+                    $name,
+                    $objectType,
+                    $classType
+                )
+            );
+        }
+    }
+
+    /**
+     * Creates an anonymous function that checks if the given hostname is valid or not.
+     *
+     * @return callable
+     */
+    public static function getIsValidHostname()
+    {
+        return function ($hostname) {
+            return Validate::isValidHostname($hostname);
+        };
+    }
+
+    /**
+     * Throws an exception if the string is not of a valid hostname.
+     *
+     * @param string $hostname String to check.
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return boolean
+     */
+    public static function isValidHostname($hostname)
+    {
+        if (defined('FILTER_VALIDATE_DOMAIN')) {
+            $isValid = filter_var($hostname, FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME);
+        } else {
+            // (less accurate) fallback for PHP < 7.0
+            $isValid = preg_match('/^[a-z0-9_-]+(\.[a-z0-9_-]+)*$/i', $hostname);
+        }
+
+        if ($isValid) {
+            return true;
+        } else {
+            throw new \RuntimeException(
+                sprintf(Resources::INVALID_CONFIG_HOSTNAME, $hostname)
+            );
+        }
+    }
+
+    /**
+     * Creates a anonymous function that check if the given uri is valid or not.
+     *
+     * @return callable
+     */
+    public static function getIsValidUri()
+    {
+        return function ($uri) {
+            return Validate::isValidUri($uri);
+        };
+    }
+
+    /**
+     * Throws exception if the string is not of a valid uri.
+     *
+     * @param string $uri String to check.
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return boolean
+     */
+    public static function isValidUri($uri)
+    {
+        $isValid = filter_var($uri, FILTER_VALIDATE_URL);
+
+        if ($isValid) {
+            return true;
+        } else {
+            throw new \RuntimeException(
+                sprintf(Resources::INVALID_CONFIG_URI, $uri)
+            );
+        }
+    }
+
+    /**
+     * Throws exception if the provided variable type is not object.
+     *
+     * @param mixed  $var  The variable to check.
+     * @param string $name The parameter name.
+     *
+     * @throws InvalidArgumentTypeException.
+     *
+     * @return boolean
+     */
+    public static function isObject($var, $name)
+    {
+        if (!is_object($var)) {
+            throw new InvalidArgumentTypeException('object', $name);
+        }
+
+        return true;
+    }
+
+    /**
+     * Throws exception if the object is not of the specified class type.
+     *
+     * @param mixed  $objectInstance An object that requires class type validation.
+     * @param string $class          The class the object instance should be.
+     * @param string $name           The parameter name.
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return boolean
+     */
+    public static function isA($objectInstance, $class, $name)
+    {
+        Validate::canCastAsString($class, 'class');
+        Validate::notNull($objectInstance, 'objectInstance');
+        Validate::isObject($objectInstance, 'objectInstance');
+
+        $objectType = get_class($objectInstance);
+
+        if (is_a($objectInstance, $class)) {
+            return true;
+        } else {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    Resources::INSTANCE_TYPE_VALIDATION_MSG,
+                    $name,
+                    $objectType,
+                    $class
+                )
+            );
+        }
+    }
+
+    /**
+     * Validate if method exists in object
+     *
+     * @param object $objectInstance An object that requires method existing
+     *                               validation
+     * @param string $method         Method name
+     * @param string $name           The parameter name
+     *
+     * @return boolean
+     */
+    public static function methodExists($objectInstance, $method, $name)
+    {
+        Validate::canCastAsString($method, 'method');
+        Validate::notNull($objectInstance, 'objectInstance');
+        Validate::isObject($objectInstance, 'objectInstance');
+
+        if (method_exists($objectInstance, $method)) {
+            return true;
+        } else {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    Resources::ERROR_METHOD_NOT_FOUND,
+                    $method,
+                    $name
+                )
+            );
+        }
+    }
+
+    /**
+     * 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::canCastAsString($value, 'value');
+
+        try {
+            new \DateTime($value);
+            return true;
+        } catch (\Exception $e) {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    Resources::ERROR_INVALID_DATE_STRING,
+                    $name,
+                    $value
+                )
+            );
+        }
+    }
+
+    /**
+     * Validate if the provided array has key, throw exception otherwise.
+     *
+     * @param  string  $key   The key to be searched.
+     * @param  string  $name  The name of the array.
+     * @param  array   $array The array to be validated.
+     *
+     * @throws \UnexpectedValueException
+     * @throws \InvalidArgumentException
+     *
+     * @return  boolean
+     */
+    public static function hasKey($key, $name, array $array)
+    {
+        Validate::isArray($array, $name);
+
+        if (!array_key_exists($key, $array)) {
+            throw new \UnexpectedValueException(
+                sprintf(
+                    Resources::INVALID_VALUE_MSG,
+                    $name,
+                    sprintf(Resources::ERROR_KEY_NOT_EXIST, $key)
+                )
+            );
+        }
+
+        return true;
+    }
+}