Exemplo n.º 1
0
        public async Task <MetaData> FilesAsync(string path, Stream targetStream, string rev = null, string asTeamMember = null)
        {
            MetaData            fileMetadata = null;
            HttpResponseMessage restResponse = await _requestExecuter.Execute(() => _requestGenerator.Files(_options.Root, path, rev, asTeamMember)).ConfigureAwait(false);

            await _requestExecuter.CheckForError(restResponse, false).ConfigureAwait(false);

            long?length = restResponse.Content.Headers.ContentLength;

            if (length == null)
            {
                IEnumerable <string> metadatas;
                if (restResponse.Headers.TryGetValues("x-dropbox-metadata", out metadatas))
                {
                    string metadata = metadatas.FirstOrDefault();
                    if (metadata != null)
                    {
                        fileMetadata = JsonConvert.DeserializeObject <MetaData>(metadata);
                        length       = fileMetadata.bytes;
                    }
                }
            }
            string etag = "";
            IEnumerable <string> etags;

            if (restResponse.Headers.TryGetValues("etag", out etags))
            {
                etag = etags.FirstOrDefault();
            }


            long?read = 0;

            do
            {
                long?from = read;
                long?to   = read + _options.ChunkSize;
                if (to > length)
                {
                    to = length;
                }

                restResponse =
                    await
                    _requestExecuter.Execute(() => _requestGenerator.FilesRange(_options.Root, path, from.Value, to.Value - 1, etag, rev, asTeamMember)).ConfigureAwait(false);

                await restResponse.Content.CopyToAsync(targetStream).ConfigureAwait(false);

                read += restResponse.Content.Headers.ContentLength;

                if (read >= length)
                {
                    break;
                }
            } while (restResponse.StatusCode == HttpStatusCode.PartialContent);

            return(fileMetadata);
        }
Exemplo n.º 2
0
        public async Task <MetaData> FilesAsync(string path, Stream targetStream, string rev = null, string asTeamMember = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            MetaData fileMetadata = null;

            using (var restResponse = await _requestExecuter.Execute(() => _requestGenerator.Files(_options.Root, path, rev, asTeamMember), cancellationToken: cancellationToken).ConfigureAwait(false))
            {
                await _requestExecuter.CheckForError(restResponse, false).ConfigureAwait(false);

                long?length = restResponse.Content.Headers.ContentLength;
                if (length == null)
                {
                    IEnumerable <string> metadatas;
                    if (restResponse.Headers.TryGetValues("x-dropbox-metadata", out metadatas))
                    {
                        string metadata = metadatas.FirstOrDefault();
                        if (metadata != null)
                        {
                            fileMetadata = JsonConvert.DeserializeObject <MetaData>(metadata);
                            length       = fileMetadata.bytes;
                        }
                    }
                }
                string etag = "";
                IEnumerable <string> etags;
                if (restResponse.Headers.TryGetValues("etag", out etags))
                {
                    etag = etags.FirstOrDefault();
                }


                long read    = 0;
                bool hasMore = true;
                do
                {
                    long from = read;
                    long to   = read + _options.ChunkSize;

                    using (var restResponse2 = await _requestExecuter.Execute(() => _requestGenerator.FilesRange(_options.Root, path, from, to - 1, etag, rev, asTeamMember), cancellationToken: cancellationToken).ConfigureAwait(false))
                    {
                        await restResponse2.Content.CopyToAsync(targetStream).ConfigureAwait(false);

                        read += (restResponse2.Content.Headers.ContentLength ?? 0);
                        if (length.HasValue && read >= length.Value)
                        {
                            hasMore = false;
                        }
                        else if (restResponse2.StatusCode == HttpStatusCode.OK)
                        {
                            hasMore = false;
                        }
                    }
                } while (hasMore);
            }
            return(fileMetadata);
        }
Exemplo n.º 3
0
        public async Task <MetaData> FilesAsync(string path, Stream targetStream, string rev = null,
                                                string asTeamMember = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            MetaData fileMetadata = null;
            string   etag         = "";
            long?    length       = null;

            try
            {
                using (var restResponse = await _requestExecuter.Execute(
                           () => _requestGenerator.Files(_options.Root, path, rev, asTeamMember),
                           cancellationToken: cancellationToken).ConfigureAwait(false))
                {
                    await _requestExecuter.CheckForError(restResponse, false, cancellationToken).ConfigureAwait(false);

                    length = restResponse.Content.Headers.ContentLength;
                    if (length == null)
                    {
                        IEnumerable <string> metadatas;
                        if (restResponse.Headers.TryGetValues("x-dropbox-metadata", out metadatas))
                        {
                            string metadata = metadatas.FirstOrDefault();
                            if (metadata != null)
                            {
                                fileMetadata = JsonConvert.DeserializeObject <MetaData>(metadata);
                                length       = fileMetadata.bytes;
                            }
                        }
                    }
                    IEnumerable <string> etags;
                    if (restResponse.Headers.TryGetValues("etag", out etags))
                    {
                        etag = etags.FirstOrDefault();
                    }
                }
            }
            catch (HttpException)
            {
                // Retry the Files request now with GET method in order to retrieve the full error message from the request
                using (var restResponseWithContent = await _requestExecuter.Execute(
                           () => _requestGenerator.Files(_options.Root, path, rev, asTeamMember, true),
                           cancellationToken: cancellationToken).ConfigureAwait(false))
                {
                    await
                    _requestExecuter.CheckForError(restResponseWithContent, false, cancellationToken)
                    .ConfigureAwait(false);
                }
                throw;
            }


            long read    = 0;
            bool hasMore = true;

            do
            {
                long from = read;
                long to   = read + _options.ChunkSize;

                using (var restResponse2 = await _requestExecuter.Execute(() => _requestGenerator.FilesRange(_options.Root, path, from, to - 1, etag, rev, asTeamMember), cancellationToken: cancellationToken).ConfigureAwait(false))
                {
                    try
                    {
                        using (cancellationToken.Register(restResponse2.Dispose))
                            await restResponse2.Content.CopyToAsync(targetStream).ConfigureAwait(false);
                    }
                    catch (HttpRequestException ex)
                    {
                        if (ex.InnerException != null && ex.InnerException is ObjectDisposedException)
                        {
                            cancellationToken.ThrowIfCancellationRequested();
                        }
                        throw;
                    }
                    catch (ObjectDisposedException)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                    }

                    read += (restResponse2.Content.Headers.ContentLength ?? 0);
                    if (length.HasValue && read >= length.GetValueOrDefault())
                    {
                        hasMore = false;
                    }
                    else if (restResponse2.StatusCode == HttpStatusCode.OK)
                    {
                        hasMore = false;
                    }
                }
            } while (hasMore);


            return(fileMetadata);
        }
Exemplo n.º 4
0
        public async Task <MetaData> FilesAsync(string path, Stream targetStream, IProgress <MyTaskProgressReport> progress = null, string rev = null, string asTeamMember = null)
        {
            MetaData fileMetadata = null;

            using (var restResponse = await _requestExecuter.Execute(() => _requestGenerator.Files(_options.Root, path, rev, asTeamMember)).ConfigureAwait(false))
            {
                await _requestExecuter.CheckForError(restResponse, false).ConfigureAwait(false);

                long?length = restResponse.Content.Headers.ContentLength;
                if (length == null)
                {
                    IEnumerable <string> metadatas;
                    if (restResponse.Headers.TryGetValues("x-dropbox-metadata", out metadatas))
                    {
                        string metadata = metadatas.FirstOrDefault();
                        if (metadata != null)
                        {
                            fileMetadata = JsonConvert.DeserializeObject <MetaData>(metadata);
                            length       = fileMetadata.bytes;
                        }
                    }
                }
                string etag = "";
                IEnumerable <string> etags;
                if (restResponse.Headers.TryGetValues("etag", out etags))
                {
                    etag = etags.FirstOrDefault();
                }
                targetStream.SetLength((long)length);
                long?read    = 0;
                bool hasMore = true;
                do
                {
                    long?from = read;
                    long?to   = read + _options.ChunkSize;
                    if (to > length)
                    {
                        to = length;
                    }
                    if (from >= length)
                    {
                        break;
                    }

                    using (var restResponse2 = await _requestExecuter.Execute(() => _requestGenerator.FilesRange(_options.Root, path, from.Value, to.Value - 1, etag, rev, asTeamMember)).ConfigureAwait(false))
                    {
                        await restResponse2.Content.CopyToAsync(targetStream).ConfigureAwait(false);

                        read += restResponse2.Content.Headers.ContentLength;

                        if (progress != null)
                        {
                            progress.Report(new MyTaskProgressReport {
                                CurrentProgressAmount = read, TotalProgressAmount = length
                            });
                        }

                        if (read >= length)
                        {
                            hasMore = false;
                        }
                        else if (restResponse2.StatusCode == HttpStatusCode.OK)
                        {
                            hasMore = false;
                        }
                    }
                } while (hasMore);
            }
            return(fileMetadata);
        }