Custom Tool - Slow File Upload Speed

Hello Greg-DB 

Upload speeds are not major concern as of now but failures are.

We did a 2 TB migration using our custom tool and encountered "too_many_requests" failure as the end stages of the migration.

Thousands of files reported such failures which won't be acceptable to users.

We upload many files in parallel but using UploadSessionStartAsync, UploadSessionAppendV2Async & UploadSessionFinishBatchAsync APIs.

We do a wait and retry for Rate Failures as recommended by Dropbox and so we thought we should be good.

However, many files still fail due to "too_many_requests".

I am writing the relevant C# code snipped we have implemented for your reference.

Can you please give us some direction to minimize the Rate Failure exceptions and hence reduce upload failures.

        public async Task SendUploadFragment(DropboxUploadSession uploadSession, byte[] fragmentBuffer, long offset)
        {
            string errorlog = ConfigurationManager.AppSettings["ErrorLog"];
            int retry = 3;
            DropboxApi.DropboxClient clientadmin = null;
            DropboxApi.DropboxTeamClient teamclient = null;

            try
            {
                for (int i = 1; i <= retry; i++)
                {
                    try
                    {
                        Item data = new Item();

                        if (!String.IsNullOrEmpty(this.CurrentToken.RefreshToken))
                        {
                            string appkey = SyncProDropboxAppKey;
                            string appsecret = SyncProDropboxAppSecret;
                            teamclient = new DropboxApi.DropboxTeamClient(this.CurrentToken.RefreshToken, appkey, appsecret);
                        }
                        else
                        {
                            teamclient = new DropboxApi.DropboxTeamClient(this.CurrentToken.AccessToken);
                        }

                        clientadmin = teamclient.AsMember(this.TeamMemberId);

                        using (var memStream = new MemoryStream(fragmentBuffer, 0, fragmentBuffer.Length))
                        {
							//1. When No Upload session has been created so far
                            if (String.IsNullOrEmpty(uploadSession.SessionId))
                            {							  
							  try
                              {
							        //If multiple fragment session
									if (!uploadSession.islastfragment)
									{
										UploadSessionStartArg args = new UploadSessionStartArg();
										UploadSessionType sessiontype = new UploadSessionType();
										var result = await clientadmin.Files.UploadSessionStartAsync(false, sessiontype.AsConcurrent, memStream);
										uploadSession.SessionId = result.SessionId;
									}
									else
									{ 
									 //If single fragment session
											UploadSessionType sessiontype = new UploadSessionType();

											var result = await clientadmin.Files.UploadSessionStartAsync(true, sessiontype.AsConcurrent, memStream);
											uploadSession.SessionId = result.SessionId;

											var cursor2 = new UploadSessionCursor(uploadSession.SessionId, (ulong)(offset + fragmentBuffer.Length));
											UploadSessionFinishArg arg = new UploadSessionFinishArg(cursor2, new CommitInfo(uploadSession.Item.PathDisplay));

											args.Add(arg);
											break;
									 }
                                }
								catch (Exception ex)
                                {     
							            //Log Exception
                                        if (ex is DropboxApi.RateLimitException)
                                        {
                                            try
                                            {
                                                Thread.Sleep(((DropboxApi.RateLimitException)ex).RetryAfter * 1000);
                                            }
                                            catch (Exception ex1)
                                            {

                                            }
                                        }

                                        Thread.Sleep(1000);
                                        throw ex;                                     
                                }                              
                            }
                            else
                            {
                                var cursor = new UploadSessionCursor(uploadSession.SessionId, (ulong)offset);

								//If last fragment of session
                                if (uploadSession.islastfragment)
                                {
                                    try
                                    {
                                        await clientadmin.Files.UploadSessionAppendV2Async(cursor, true, memStream);
                                        var cursor2 = new UploadSessionCursor(uploadSession.SessionId, (ulong)(offset + fragmentBuffer.Length));
                                        UploadSessionFinishArg arg = new UploadSessionFinishArg(cursor2, new CommitInfo(uploadSession.Item.PathDisplay));
                                        args.Add(arg);
                                    
                                        break;
                                    }
                                    catch (Exception ex)
                                    {      
										//Log Exception									
                                        if (ex is DropboxApi.RateLimitException)
                                        {
                                            try
                                            {                                                
                                                Thread.Sleep(((DropboxApi.RateLimitException)ex).RetryAfter * 1000);
                                            }
                                            catch (Exception ex1)
                                            {

                                            }
                                        }

                                        Thread.Sleep(1000);                                        
                                    }                                    
                                }
                                else  //If not the last fragment of Session
                                {
                                    try
                                    {
                                        await clientadmin.Files.UploadSessionAppendV2Async(cursor, false, memStream);
                                        break;
                                    }
                                    catch (Exception ex)
                                    {   
										//Log Exception
                                        if (ex is DropboxApi.RateLimitException)
                                        {
                                            try
                                            {                                                
                                                Thread.Sleep(((DropboxApi.RateLimitException)ex).RetryAfter * 1000);
                                            }
                                            catch (Exception ex1)
                                            {

                                            }
                                        }

                                        Thread.Sleep(1000);                                     
                                    }
                                }
                            }
                        }
                        break;
                    }
                    catch (Exception ex)
                    {
                        string isgeneratelog = Global.IsErrorLog == false ? "0" : "1";                        
                        if (ex is DropboxApi.RateLimitException)
                        {
                            try
                            {                                
                                Thread.Sleep(((DropboxApi.RateLimitException)ex).RetryAfter * 1000);
                            }
                            catch (Exception ex1)
                            {                                
                            }
                        }

                        Thread.Sleep(1000);                      
                    }
                    finally
                    {
                        try
                        {
                            if (teamclient != null)
                            {
                                teamclient.Dispose();
                                teamclient = null;
                            }

                            if (clientadmin != null)
                            {
                                clientadmin.Dispose();
                                clientadmin = null;
                            }
                        }
                        catch (Exception ex)
                        {

                        }
                    }
                }
            }
            catch (Exception ex)
            {
                string isgeneratelog = Global.IsErrorLog == false ? "0" : "1";
                if (isgeneratelog == "1")
                {
                    try
                    {
                        System.IO.File.AppendAllText(errorlog, "\r\nDateTime: " + DateTime.Now.ToString() + "\r\nPathDisplay: " + uploadSession.Item.PathDisplay +

                        "\r\n" + ex.Message + "\r\n" + ex.StackTrace + "\r\n");
                    }
                    catch (Exception ex1)
                    {

                    }
                }

                throw ex;
            }
            finally
            {
                clientadmin = null;
                fragmentBuffer = null;
                teamclient = null;
            }
        }



		public async Task<string> UploadBatchFinish()
        {
            DropboxApi.DropboxTeamClient teamclient = null;
            DropboxApi.DropboxClient clientadmin = null;

            try
            {
                
                if (!String.IsNullOrEmpty(this.CurrentToken.RefreshToken))
                {
                    string appkey = SyncProDropboxAppKey;
                    string appsecret = SyncProDropboxAppSecret;
                    teamclient = new DropboxApi.DropboxTeamClient(this.CurrentToken.RefreshToken, appkey, appsecret);
                }
                else
                {
                    teamclient = new DropboxApi.DropboxTeamClient(this.CurrentToken.AccessToken);
                }

                clientadmin = teamclient.AsMember(this.TeamMemberId);
               
                UploadSessionFinishBatchArg batchArg = new UploadSessionFinishBatchArg(args);
                var result = await clientadmin.Files.UploadSessionFinishBatchAsync(batchArg);
               
                if (result != null && result.AsAsyncJobId != null && result.AsAsyncJobId.Value != null)
                {
                    return result.AsAsyncJobId.Value;
                }               
            }
            catch (Exception ex)
            {                
                throw ex;
            }
            finally
            {
                teamclient = null;
                clientadmin = null;
            }

            return "";
        }

Thanks,

Gagan