Tus resumable upload socket timeout exception occured

[Kukadiya-Anil-K]

Caused by: android.system.ErrnoException: sendto failed: ECONNRESET (Connection reset by peer) W/System.err: at libcore.io.Posix.sendtoBytes(Native Method) W/System.err: at libcore.io.Posix.sendto(Posix.java:176) W/System.err: at libcore.io.BlockGuardOs.sendto(BlockGuardOs.java:278) W/System.err: at libcore.io.IoBridge.sendto(IoBridge.java:513) W/System.err: ... 18 more D/IO Exception ========: java.net.SocketException: sendto failed: ECONNRESET (Connection reset by peer)

[Acconut]

The stack trace on its own is not very helpful, please share the full error message and also your code handling the tus uploads.

[Kukadiya-Anil-K]

package com.hvk.tusresumableuploadanl;

import android.app.AlertDialog;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;

import com.nbsp.materialfilepicker.MaterialFilePicker;
import com.nbsp.materialfilepicker.ui.FilePickerActivity;

import java.io.File;
import java.io.IOException;
import java.net.URL;

import io.tus.java.client.TusClient;
import io.tus.java.client.TusUpload;
import io.tus.java.client.TusUploader;

public class MainActivity extends AppCompatActivity {
    private final int REQUEST_FILE_SELECT = 1;
    private TusClient client;
    private TextView status;
    private Button pauseButton;
    private Button resumeButton;
    private UploadTask uploadTask;
    private ProgressBar progressBar;
    private Uri fileUri;
    private OutOfMemoryError error;
    private Exception exception1;
    SharedPreferences pref;
    static String breakvalue;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        try {
            SharedPreferences pref = getSharedPreferences("tus", 0);
//            System.setProperty("http.strictPostRedirect", "false");

            client = new TusClient();
//            client.setUploadCreationURL(new URL("https://master.tus.io/files/"));

          client.setUploadCreationURL(new URL("http://192.168.0.24:2000/files/"));

            client.enableResuming(new TusPreferencesURLStore(pref));

        } catch (Exception e) {
            showError(e);
        }

        status = (TextView) findViewById(R.id.status);
        progressBar = (ProgressBar) findViewById(R.id.progressBar);

        Button button = (Button) findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new MaterialFilePicker()
                        .withActivity(MainActivity.this)
                        .withRequestCode(REQUEST_FILE_SELECT)
//                        .withFilter(Pattern.compile(".*\\.txt$")) // Filtering files and directories by file name using regexp
                        .withFilterDirectories(true) // Set directories filterable (false by default)
                        .withHiddenFiles(true) // Show hidden files and folders
                        .start();

            }
        });

        pauseButton = (Button) findViewById(R.id.pause_button);
        pauseButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                pauseUpload();
                setPauseButtonEnabled(false);
            }
        });

        resumeButton = (Button) findViewById(R.id.resume_button);
        resumeButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                resumeUpload();
            }
        });
    }

    private void beginUpload(Uri uri) {
        fileUri = uri;
        resumeUpload();
    }

    public void setPauseButtonEnabled(boolean enabled) {
        pauseButton.setEnabled(enabled);
        resumeButton.setEnabled(!enabled);
        if (breakvalue=="loopbreak"){
            breakvalue=null;
            resumeUpload();
        }
//        resumeUpload();
    }

    public void pauseUpload() {
        uploadTask.cancel(false);

    }

    public void resumeUpload() {
        try {
            TusUpload upload = new TusAndroidUpload(fileUri, this);
            uploadTask = new UploadTask(this, client, upload);
            uploadTask.execute(new Void[0]);
        } catch (Exception e) {
            showError(e);
        }
    }

    private void setStatus(String text) {
        status.setText(text);
    }

    private void setUploadProgress(int progress) {
        progressBar.setProgress(progress);
    }

    private class UploadTask extends AsyncTask<Void, Long, URL> {
        private MainActivity activity;
        private TusClient client;
        private TusUpload upload;
        private Exception exception;

        public UploadTask(MainActivity activity, TusClient client, TusUpload upload) {
            this.activity = activity;
            this.client = client;
            this.upload = upload;
        }

        @Override
        protected void onPreExecute() {

            activity.setStatus("Upload selected...");
            activity.setPauseButtonEnabled(true);
        }

        @Override
        protected void onPostExecute(URL uploadURL) {

            if (error != null) {
                resumeUpload();
                error = null;
            }
            if (exception1 != null) {
                uploadTask.cancel(false);
                Log.e("Run after 5 second ====", exception1.toString());
                exception1 = null;
                client = new TusClient();
                resumeUpload();
            }
            if (uploadURL != null) {
                activity.setStatus("Upload finished!\n" + uploadURL.toString());
                activity.setPauseButtonEnabled(false);
            }
        }

        @Override
        protected void onCancelled() {
            if (exception != null) {
                activity.showError(exception);
            }

            activity.setPauseButtonEnabled(false);
        }

        @Override
        protected void onProgressUpdate(Long... updates) {
            long uploadedBytes = updates[0];
            long totalBytes = updates[1];
            activity.setStatus(String.format("Uploaded %d/%d.", uploadedBytes, totalBytes));
            activity.setUploadProgress((int) ((double) uploadedBytes / totalBytes * 100));
        }

        @Override
        protected URL doInBackground(Void... params) {
            try {
                TusUploader uploader = client.resumeOrCreateUpload(upload);
                long totalBytes = upload.getSize();
                long uploadedBytes = uploader.getOffset();

                // Upload file in 10KB chunks
                uploader.setChunkSize(512 * 1024);

                try {

                    while (!isCancelled() && uploader.uploadChunk() > -1) {

                        uploadedBytes = uploader.getOffset();
                        publishProgress(uploadedBytes, totalBytes);

                    }
                } catch (OutOfMemoryError error) {
                    MainActivity.this.error = error;
                    error.printStackTrace();
                }

                uploader.finish();
                return uploader.getUploadURL();

// here exception occured on live server sersocket exception(reset peers)
            } catch (IOException e) {
                exception1 = e; 
                e.printStackTrace();
                Log.d("IO Exception ========", e.toString());
            } catch (Exception e) {
                exception = e;
//                cancel(true);
            }
            return null;
        }
    }

    private void showError(Exception e) {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("Internal error");
        builder.setMessage(e.getMessage());
        AlertDialog dialog = builder.create();
        dialog.show();
        e.printStackTrace();
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode != RESULT_OK) {
            return;
        }

        if (requestCode == REQUEST_FILE_SELECT) {

//            Uri uri = data.getData();
//            beginUpload(uri);

            String filePath = data.getStringExtra(FilePickerActivity.RESULT_FILE_PATH);
            if (new File(filePath).exists()) {
                beginUpload(Uri.fromFile(new File(filePath).getAbsoluteFile()));
            }

        }
    }
}

[Kukadiya-Anil-K]

} catch (IOException e) { exception1 = e; e.printStackTrace(); Log.d("IO Exception ========", e.toString()); }

In this section Exception occured socketException(Reset peers) or socket TimeoutException(Reset Peers)

[Acconut]

I don't see an obvious problem with your code. What tus server are you using? Are you using a proxy (e.g. nginx) in front of it which might be configured to set a timeout? Also, does this exception get thrown directly when the upload is started or only after parts of the file are already uploaded?

Often, connection resets occur in production without being able to fully prevent them. In these cases, tus is able to resume the upload were it was interrupted using the TusExecutor class. Please have a look a this example (https://github.com/tus/tus-java-client/#usage) to see how you can use it.

[Kukadiya-Anil-K]

(https://github.com/tus/tus-java-client/#usage) is already show its not work for me

[Acconut]

What do you mean? I don't understand your sentence. You are not using TusExecutor in the code you pasted above.

[Kukadiya-Anil-K]

i solved my problem using break loop

                int i=0;                   
                while (!isCancelled() && uploader.uploadChunk() > -1) {

                    uploadedBytes = uploader.getOffset();
                    publishProgress(uploadedBytes, totalBytes);
                     i++;
                     if(i==2){
                      i=0;
                       resumeupload();
                       break;
                    }
                }

[Kukadiya-Anil-K]

Sorry but i will try TusExecutor its method not work for me after I used above code , same issues occured both method .