Flexible retry library for Dio package

if possible can an on retry callback is called with the status of the request

(using it to let user know that request failed and the code is retrying)

Hi @rodion-m I have tried to use your library in my project. I have several tests of my communication layer including test for incorrect url. Unfortunately test stops working after adding your interceptor. Here is what I have discovered. RetryInterceptor.onError do not handling errors that could arise in this method. For example in my case I have had incorrect url (http ://github.com with spaces) that makes troubles when I am specifying logPrint function. Interceptor prepare output string for logPrint function and call err.requestOptions.uri which throws exception FormatException: Illegal scheme character (at character 5). This exception bubble out without corresponding handling.

The solution could be simple in my case, just use path instead of uri or something similar in that direction. But I propose you to think about general error handling to avoid issues for example when _retryEvaluator could throw an error.

Would it be possible to add specific status codes beside the default codes to 'dio_smart_retry'? For example I would like to retry on status code 401, but it is not included. Please add an option to set optional status codes. Thank you!

We use an API that returns no default HTTP Status Codes for a lot of cases.

There is no way to change the API, so would be nice to be able to override the default status codes that should retry.

Related: https://github.com/rodion-m/dio_smart_retry/issues/11

Hi!

I dont know if im doing something wrong, but if i set the responseType to ResponseType.plain and the RetryInterceptor is executed after a timeout, the interceptor seems to set the responseType to ResponseType.json.

Example:

``

final dio = Dio(
  BaseOptions(
    baseUrl: rootUri,
    connectTimeout: 3000,
    receiveTimeout: 5000,
    headers: headers,
    responseType: ResponseType.plain,
  ),
);

dio.interceptors.add(
  RetryInterceptor(
    dio: dio,
    logPrint: log, // specify log function (optional)
    retryDelays: const [
      Duration(seconds: 3), // wait 1 sec before first retry
      Duration(seconds: 5), // wait 2 sec before second retry
      Duration(seconds: 10), // wait 3 sec before third retry
    ],
  ),
);

try {
  response = await dio.get(url);
...

If there is no timeout, everything works fine.

Any ideas?

Thanks!

retry package works great if there is an error on initial request it goes into retry mode and if its successful retry does not happen

so I wanted to see what happens if server is down and midway turns on

• I closed the server
• retry package started retrying I set retry to 3
• when the attempt number was 1 I turned on the server but then It still kept retrying

` Future uploadImage( {required File file, required Function onProgressUpdate}) async { Response? response;

var dio = Dio();

dio.interceptors.addAll([
  ///For Logging
  PrettyDioLogger(
      requestHeader: true,
      requestBody: true,
      responseBody: true,
      responseHeader: false,
      error: true,
      compact: true,
      maxWidth: 90),

  ///For Retrying
  RetryInterceptor(
    retryEvaluator: (DioError error, int attempt) {
      print('---------Rety Intercept Start---------');
      print('inty');
      print(attempt);
      ScaffoldMessenger.of(context).clearSnackBars();
      timerSnackbar(
        backgroundColor: Colors.black,
        context: context,
        buttonLabel: '',
        contentText:
            "Error ${error.error} - Attempt ${attempt.toString()} of 3",
        // buttonPrefixWidget: Image.asset(
        //   'assets/undo.png',
        //   width: 17.0,
        //   height: 15.0,
        //   alignment: Alignment.topCenter,
        //   color: Colors.blue[100],
        // ),
        afterTimeExecute: () => print("Operation Execute."),
        second: 5,
      );

      print('dioError');
      print(error.error.toString());
      print('---------Rety Intercept End---------');
      return true;
    },
    dio: dio,
    logPrint: print, // specify log function (optional)
    retries: 3, // retry count (optional)
    retryDelays: const [
      // set delays between retries (optional)
      Duration(seconds: 10), // wait 10 sec before first retry
      Duration(seconds: 10), // wait 10 more sec before second retry
      Duration(seconds: 10), // wait 10 more sec before third retry
      ///You can use timer snackbar package and show time before sending attempt again
    ],
  )
]);
String fileName = file.path.split('/').last;
FormData formData = FormData.fromMap({
  "image": await MultipartFile.fromFile(file.path, filename: fileName),
});

response = await dio.post(
  "http://127.0.0.1:8000/uploadImage/",
  data: formData,
  onSendProgress: (v1, v2) {
    ///v2 is the total size of file
    ///v1 is the current progress
    /// example output  v1 value is 590007 v2 value is 630413
    print('v1 value is ${v1.toString()}');
    print('v2 value is ${v2.toString()}');

    onProgressUpdate(((v1 / v2) * 100).toStringAsFixed(2));
  },
  onReceiveProgress: (v1, v2) {
    print('v1 from recieveProgress $v1');
    print('v2 from recieveProgress $v2');
  },
  options: Options(
    followRedirects: false,
  ),
);
print(response.data);
print(response.statusMessage);
return await response.data;

}`

At first I get web socket error then I get 'Cant finalise a finalised multipart'

Also I was testing cancel token and if token is cancel it still retry is there a way I cancel retry via a function

Hello I have tried to use the disableRetry but it isn't working correctly.

This is my dio request

final requestOptions = RequestOptions(
      method: method,
      baseUrl: _dio.options.baseUrl,
      path: path,
      headers: headers,
      data: data,
      queryParameters: queryParameters,
      onSendProgress: onSendProgress,
      onReceiveProgress: onReceiveProgress,
      extra: {
        'Test': 'This is an extra test'
      },
    )..disableRetry = true;
return _dio.fetch(requestOptions);

I have looked into the problem and it looks as though the extra on the requestOptions is empty on the onError override of the interceptor.

@override
  Future onError(DioError err, ErrorInterceptorHandler handler) async {
    print(err.requestOptions.extra); //<--- this is always empty even when extra parameters are added.
}

Not sure if its a dio issue.

when request is canceled using cancelToken the retries keep going instead of stopping

what i think should happed is the to check if the request cancle token was canceled before trying again

Hello, I'm pleasure to using your open source. I want you to know A lint warning is occurs at the line of code below.

import 'package:dio_smart_retry/dio_smart_retry.dart';
import 'package:dio_smart_retry/src/http_status_codes.dart';

So I had to change it like this

import 'package:dio_smart_retry/dio_smart_retry.dart';
// ignore_for_file: implementation_imports
import 'package:dio_smart_retry/src/http_status_codes.dart' as dio_smart_retry;

My flutter doctor -v is

[✓] Flutter (Channel stable, 3.3.2, on macOS 12.6 21G115 darwin-arm, locale en-KR)
    • Flutter version 3.3.2 on channel stable at /Users/9oya/flutter
    • Upstream repository https://github.com/flutter/flutter.git
    • Framework revision e3c29ec00c (12 days ago), 2022-09-14 08:46:55 -0500
    • Engine revision a4ff2c53d8
    • Dart version 2.18.1
    • DevTools version 2.15.0

I think the source code for the status code in http_status_codes.dart could be improved. Thank you.

Hi,

I'm using the latest packages:

dio: ^4.0.6
dio_smart_retry: ^1.3.2

When I post a file to the server and, it accepts only after first attemp, the error occours... here a simplified code:

    Dio dio = Dio(BaseOptions(
      baseUrl: ("https://$domain$base"),
    );

    dio.interceptors.add(
        RetryInterceptor(
          dio: dio,
          logPrint: print, // specify log function (optional)
          retries: 3, // retry count (optional)
          retryDelays: const [
            // set delays between retries (optional)
            Duration(seconds: 1), // wait 1 sec before first retry
            Duration(seconds: 2), // wait 2 sec before second retry
            Duration(seconds: 3), // wait 3 sec before third retry
          ],
        ),
      );

    final bytes = await cameraFile!.readAsBytes();
    final MultipartFile file = MultipartFile.fromBytes(bytes, filename: "teste");
    MapEntry<String, MultipartFile> a = MapEntry('teste', file);

    var options = FormData.fromMap({
      "bla": "bla",
    });

    options.files.add(a);

    var data = await dio.post("/post_test", data: options);