public static CloudBlockBlob[] GetTarget_BatchToProcess(int processBatchSize, bool processIfLess)
        {
            //options.
            //options.AccessCondition
            //StorageSupport.CurrActiveContainer.ListBlobsSegmented()
            //    ListBlobsWithPrefix("sys/AAA/TheBall.CORE/RequestResourceUsage")
            string prefix = "sys/AAA/TheBall.CORE/RequestResourceUsage/";

            BlobRequestOptions options = new BlobRequestOptions {UseFlatBlobListing = true};
            var blobList = StorageSupport.CurrActiveContainer.ListBlobxWithPrefixSegmented(prefix, processBatchSize, null, options);
            List<CloudBlockBlob> result = new List<CloudBlockBlob>();
            foreach (var blobListItem in blobList.Results)
            {
                CloudBlockBlob blob = (CloudBlockBlob) blobListItem;
                if (blob.Name == LockLocation)
                    return null;
                result.Add(blob);
            }
            if (result.Count < processBatchSize && processIfLess == false)
                return null;
            // Acquire Lock
            string lockETag;
            bool acquiredLock = StorageSupport.AcquireLogicalLockByCreatingBlob(LockLocation, out lockETag);
            if (!acquiredLock)
                return null;
            return result.ToArray();
        }

        public static Uri UploadPackageToBlob(IServiceManagement channel, string storageName, string subscriptionId, string packagePath, BlobRequestOptions blobRequestOptions)
        {
            StorageService storageService = channel.GetStorageKeys(subscriptionId, storageName);
            string storageKey = storageService.StorageServiceKeys.Primary;

            return UploadFile(storageName, storageKey, packagePath, blobRequestOptions);
        }

        public static bool DeletePhotoBlob(Guid photoId)
        {
            try
            {
                // Delete from Azure
                CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
                    ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString);

                CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

                // Get a reference to the container.
                CloudBlobContainer container = blobClient.GetContainerReference("photos");

                // Indicate that any snapshots should be deleted.
                BlobRequestOptions options = new BlobRequestOptions();
                options.DeleteSnapshotsOption = DeleteSnapshotsOption.IncludeSnapshots;

                // Specify a flat blob listing, so that only CloudBlob objects will be returned.
                // The Delete method exists only on CloudBlob, not on IListBlobItem.
                options.UseFlatBlobListing = true;

                var blob = container.GetBlobReference(photoId.ToString());

                blob.Delete(options);

                return true;
            }
            catch
            {
            }

            return false;
        }

		public IBlob Get(Uri uri)
		{
			IBlob blob = null;

			var options = new BlobRequestOptions { BlobListingDetails = BlobListingDetails.Metadata };

			var container = getContainer();
			var target = container.GetBlobReference(uri.ToString());

			try
			{
				target.FetchAttributes();
				blob = new Blob(target.Properties.ContentMD5, target.Properties.ETag)
					{ Content = target.DownloadByteArray(), ContentType = target.Properties.ContentType, };

				foreach (var key in target.Metadata.AllKeys)
				{
					blob.Metdata.Add(new KeyValuePair<string, string>(key, target.Metadata[key]));
				}
			}
			catch (StorageClientException s)
			{
				this.WriteErrorMessage(string.Format("An error occurred retrieving the blob from {0}", uri), s);
				blob = null;
			}

			return blob;
		}

        public static void Read(BlobRequestOptions mapped, CloudBlob blob, ReaderDelegate reader)
        {
            blob.FetchAttributes(mapped);
            var props = MapFetchedAttrbitues(blob);

            var compression = blob.Properties.ContentEncoding ?? "";
            var md5 = blob.Metadata[LokadHashFieldName];

            switch (compression)
            {
                case "gzip":
                    using (var stream = blob.OpenRead(mapped))
                    {
                        ReadAndVerifyHash(stream, s =>
                            {
                                // important is not to flush the decompression stream
                                using (var decompress = new GZipStream(s, CompressionMode.Decompress, true))
                                {
                                    reader(props, decompress);
                                }
                            }, md5);
                    }

                    break;
                case "":
                    using (var stream = blob.OpenRead(mapped))
                    {
                        ReadAndVerifyHash(stream, s => reader(props, s), md5);
                    }
                    break;
                default:
                    var error = string.Format("Unsupported ContentEncoding '{0}'", compression);
                    throw new InvalidOperationException(error);
            }
        }

        public static void ParallelUpload(this CloudBlockBlob blobRef, string filename, BlobRequestOptions options)
        {
            if (null == options)
            {
                options = new BlobRequestOptions()
                {
                    Timeout = blobRef.ServiceClient.Timeout,
                    RetryPolicy = RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount, RetryPolicies.DefaultClientBackoff)
                };
            }

            // get upload history if any
            UploadInfo uploadInfo = UploadInfo.LoadByUploadFilename(filename);

            using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
            {
                blobRef.ParallelUpload(fs, uploadInfo, options);
            }

            // upload completed no history needed - delete it
            if (File.Exists(uploadInfo.LogFilename))
                File.Delete(uploadInfo.LogFilename);

            Console.WriteLine("\nUpload completed.");
        }

        public static List<BlobHelper> GetAll(string container, string account, string key)
        {
            List<BlobHelper> list = new List<BlobHelper>();
            CloudBlobContainer cont = StorageHelper.Container.Get(account,key, container);

            if (cont == null)
                return list;

            BlobRequestOptions opt = new BlobRequestOptions();
            opt.BlobListingDetails = BlobListingDetails.All;
            opt.UseFlatBlobListing = true;

            foreach (IListBlobItem blob in cont.ListBlobs(opt))
            {
                CloudBlockBlob b = blob as CloudBlockBlob;
                if (b == null)
                    continue;

                b.FetchAttributes(opt);

                BlobHelper bh = new BlobHelper();
                bh.Url = b.Uri.ToString();
                bh.Name = b.Uri.Segments[b.Uri.Segments.Length - 1];
                bh.Size = b.Properties.Length;
                bh.Type = b.Properties.ContentType;
                bh.BlobType = b.Properties.BlobType.ToString();
                bh.LastModfied = b.Properties.LastModifiedUtc;
                bh.ETag = b.Properties.ETag;
                list.Add(bh);
            }

            return list;
        }

        public static async Task<CloudBlobContainer> GetBlobContainer(string containerName)
        {
            if (String.IsNullOrEmpty(containerName))
            {
                throw new ArgumentException("containerName");
            }

            // Retrieve storage account from connection-string
            string connectionString = CloudConfigurationManager.GetSetting("CloudStorageConnectionString");
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);

            // Create the blob client 
            CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

            // Retrieve a reference to a container. Note that container name must use lower case
            CloudBlobContainer container = blobClient.GetContainerReference(containerName.ToLowerInvariant());

            // Create options for communicating with the blob container.
            BlobRequestOptions options = new BlobRequestOptions();

            // Create the container if it doesn't already exist
            bool result = await Task.Factory.FromAsync<BlobRequestOptions, bool>(container.BeginCreateIfNotExist, container.EndCreateIfNotExist, options, state: null);

            // Enable public access to blob
            BlobContainerPermissions permissions = container.GetPermissions();
            if (permissions.PublicAccess == BlobContainerPublicAccessType.Off)
            {
                permissions.PublicAccess = BlobContainerPublicAccessType.Blob;
                container.SetPermissions(permissions);
            }

            return container;
        }

        /// <summary>
        /// Uploads a file to azure store.
        /// </summary>
        /// <param name="storageName">Store which file will be uploaded to</param>
        /// <param name="storageKey">Store access key</param>
        /// <param name="filePath">Path to file which will be uploaded</param>
        /// <param name="blobRequestOptions">The request options for blob uploading.</param>
        /// <returns>Uri which holds locates the uploaded file</returns>
        /// <remarks>The uploaded file name will be guid</remarks>
        public static Uri UploadFile(string storageName, string storageKey, string filePath, BlobRequestOptions blobRequestOptions)
        {
            string baseAddress = General.BlobEndpointUri(storageName);
            var credentials = new StorageCredentialsAccountAndKey(storageName, storageKey);
            var client = new CloudBlobClient(baseAddress, credentials);
            string blobName = Guid.NewGuid().ToString();

            CloudBlobContainer container = client.GetContainerReference(ContainerName);
            container.CreateIfNotExist();
            CloudBlob blob = container.GetBlobReference(blobName);

            using (FileStream readStream = File.OpenRead(filePath))
            {
                blob.UploadFromStream(readStream, blobRequestOptions);
            }

            return new Uri(
                string.Format(
                    CultureInfo.InvariantCulture,
                    "{0}{1}{2}{3}",
                    client.BaseUri,
                    ContainerName,
                    client.DefaultDelimiter,
                    blobName));
        }

        public static Uri UploadPackageToBlob(IServiceManagement channel, string storageName, string subscriptionId, string packagePath, BlobRequestOptions blobRequestOptions)
        {
            StorageService storageService = channel.GetStorageKeys(subscriptionId, storageName);
            string storageKey = storageService.StorageServiceKeys.Primary;
            storageService = channel.GetStorageService(subscriptionId, storageName);
            string blobEndpointUri = storageService.StorageServiceProperties.Endpoints[0];

            return UploadFile(storageName, CreateHttpsEndpoint(blobEndpointUri), storageKey, packagePath, blobRequestOptions);
        }

 public static Uri UploadFile(
     string storageName,
     Uri blobEndpointUri,
     string storageKey,
     string filePath,
     BlobRequestOptions blobRequestOptions)
 {
     return cloudBlobUtility.UploadFile(storageName, blobEndpointUri, storageKey, filePath, blobRequestOptions);
 }

 public XStoreExperiment(Guid experimentId, CloudBlobClient client, string title, int requestedIterations, string instanceId)
     : base(experimentId, title, requestedIterations, instanceId)
 {
     this.instanceId = instanceId;
     this.client = client;
     this.requestOptions = new BlobRequestOptions
     {
         RetryPolicy = TrackedPolicy,
         Timeout = TimeSpan.FromMinutes(5),
     };
 }

 /// <summary>Initializes a new instance of the <see cref="ParallelUpload"/> class.</summary>
 /// <param name="source">The source stream. </param>
 /// <param name="options">The request options. </param>
 /// <param name="blockSize">The block size to use. </param>
 /// <param name="blob">The blob to upload to. </param>
 internal ParallelUpload(Stream source, BlobRequestOptions options, long blockSize, CloudBlockBlob blob)
 {
     this.sourceStream = source;
     this.blockSize = blockSize;
     this.options = options;
     this.dispensizedStreamSize = 0;
     this.blob = blob;
     this.blobHash = MD5.Create();
     this.blockList = new List<string>();
     this.parellelism = this.GetParallelismFactor();
 }

 public static Uri UploadPackageToBlob(
     StorageManagementClient storageClient,
     string storageName,
     string packagePath,
     BlobRequestOptions blobRequestOptions)
 {
     return cloudBlobUtility.UploadPackageToBlob(
         storageClient,
         storageName,
         packagePath,
         blobRequestOptions);
 }

        /// <summary>
        /// Gets the web request.
        /// </summary>
        /// <param name="serviceClient">The service client.</param>
        /// <param name="options">The options.</param>
        /// <param name="retrieveRequest">The retrieve request.</param>
        /// <returns>The web request.</returns>
        internal static HttpWebRequest GetWebRequest(CloudBlobClient serviceClient, BlobRequestOptions options, Func<int, HttpWebRequest> retrieveRequest)
        {
            CommonUtils.AssertNotNull("options", options);

            int timeoutInSeconds = options.Timeout.RoundUpToSeconds();
            AccessCondition accessCondition = options.AccessCondition;

            var webRequest = retrieveRequest(timeoutInSeconds);
            accessCondition.ApplyCondition(webRequest);
            CommonUtils.ApplyRequestOptimizations(webRequest, -1);

            return webRequest;
        }

        /// <summary>
        /// Initializes a new instance of the BlobReadStream class. 
        /// </summary>
        /// <param name="blob">The blob used for downloads.</param>
        /// <param name="options">Modifiers to be applied to the blob. After first request, the ETag is always applied.</param>
        /// <param name="readAheadInBytes">The number of bytes to read ahead.</param>
        /// <param name="verifyBlocks">Controls whether block's signatures are verified.</param>
        internal BlobReadStream(CloudBlob blob, BlobRequestOptions options, long readAheadInBytes, bool verifyBlocks)
        {
            CommonUtils.AssertNotNull("blob", blob);
            CommonUtils.AssertNotNull("options", options);
            CommonUtils.AssertInBounds("readAheadInBytes", readAheadInBytes, 0, Protocol.Constants.MaxBlobSize);

            this.Blob = blob;
            this.IntegrityControlVerificationEnabled = verifyBlocks;
            this.options = options;
            this.ReadAheadSize = readAheadInBytes;

            this.downloadedBlocksList = new DownloadedBlockCollection();
        }

        public void UploadBlock(Stream input, long offset)
        {
            input.Seek(0, SeekOrigin.Begin);

            string blockId = this.EncodeOffset(offset);
            string contentMD5 = this.CalculateMD5(input);

            var options = new BlobRequestOptions
            {
                RetryPolicy = RetryPolicies.RetryExponential(
                RetryPolicies.DefaultClientRetryCount,
                RetryPolicies.DefaultClientBackoff)
            };
            this.blob.PutBlock(blockId, input, contentMD5, options);
        }

        public Dictionary<string, string> GetReferenceHashMap()
        {
            var output = new Dictionary<string, string>();

            var options = new BlobRequestOptions();
            options.UseFlatBlobListing = true;

            foreach (var item in Container.ListBlobs(options)) {
                //var reference = item.Uri.AbsolutePath.Substring(item.Uri.AbsolutePath.IndexOf('/', 1) + 1);
                var blob = ((CloudBlob)item);

                output[blob.Name] = blob.Properties.ContentMD5;
            }

            return output;
        }

        /// <summary>Initializes a new instance of the BlobWriteStream class.</summary>
        /// <param name="blob">The blob used for uploads. </param>
        /// <param name="options">The options used for the stream. </param>
        /// <param name="blockSize">The size of the blocks to use. </param>
        internal BlobWriteStream(CloudBlockBlob blob, BlobRequestOptions options, long blockSize)
        {
            CommonUtils.AssertNotNull("blob", blob);
            CommonUtils.AssertNotNull("options", options);

            this.Blob = blob;
            this.blobHash = MD5.Create();
            this.BlockSize = blockSize;
            this.blockList = new List<string>();
            this.currentModifier = options;
            this.canWrite = true;

            var rand = new Random();
            this.blockIdSequenceNumber = (long)rand.Next() << 32;
            this.blockIdSequenceNumber += rand.Next();
        }

        // The mutex must already exists
        public Mutex(CloudBlobContainer container, string mutexName, Exception e)
        {
            blob = container.GetBlobReference(mutexName);

            byte[] b1 = { 1 };
            BlobRequestOptions requestOpt = new BlobRequestOptions();
            bool keepGoing = true;
            string oldEtag = "";
            int lastChange = 0;
            do
            {
                byte[] b;
                string eTag;
                try
                {
                    blob.FetchAttributes();
                    eTag = blob.Attributes.Properties.ETag;
                    if (eTag != oldEtag)
                    {
                        lastChange = Environment.TickCount;
                        oldEtag = eTag;
                    }
                    b = blob.DownloadByteArray();
                }
                catch (Exception)
                {
                    throw e;
                }

                requestOpt.AccessCondition = AccessCondition.IfMatch(eTag);
                if (b[0] == 0 || Environment.TickCount - lastChange > 3000) // on ne peut garder un lock plus de 3 s
                {
                    try
                    {
                        blob.UploadByteArray(b1, requestOpt);
                        keepGoing = false;
                    }
                    catch (StorageClientException ex)
                    {
                        if (ex.ErrorCode != StorageErrorCode.ConditionFailed)
                            throw;
                    }
                }
                else
                    Thread.Sleep(50);   // constante arbitraire
            } while (keepGoing);
        }