Ejemplo n.º 1
0
        /// <inheritdoc/>
        public async Task Put(Func <string> jsonData, CancellationToken?token = null, Action <RetryExceptionEventArgs> onException = null)
        {
            async Task invoke(Func <string> invokeJsonData)
            {
                string url;
                var    responseData = string.Empty;
                var    statusCode   = HttpStatusCode.OK;

                if (App.Config.OfflineMode)
                {
                    throw new FirebaseException(FirebaseExceptionReason.OfflineMode, new Exception("Offline mode"));
                }

                var c = GetClient();

                var currentJsonToInvoke = invokeJsonData();

                if (currentJsonToInvoke == null)
                {
                    try
                    {
                        url = await BuildUrl(token).ConfigureAwait(false);

                        CancellationToken invokeToken;

                        if (token == null)
                        {
                            invokeToken = new CancellationTokenSource(App.Config.DatabaseRequestTimeout).Token;
                        }
                        else
                        {
                            invokeToken = CancellationTokenSource.CreateLinkedTokenSource(token.Value, new CancellationTokenSource(App.Config.DatabaseRequestTimeout).Token).Token;
                        }

                        var result = await c.DeleteAsync(url, invokeToken).ConfigureAwait(false);

                        statusCode   = result.StatusCode;
                        responseData = await result.Content.ReadAsStringAsync().ConfigureAwait(false);

                        result.EnsureSuccessStatusCode();
                    }
                    catch (OperationCanceledException ex)
                    {
                        throw new FirebaseException(FirebaseExceptionReason.OperationCancelled, ex);
                    }
                    catch (FirebaseException ex)
                    {
                        throw ex;
                    }
                    catch (Exception ex)
                    {
                        throw new FirebaseException(ExceptionHelpers.GetFailureReason(statusCode), ex);
                    }
                }
                else
                {
                    await Silent().SendAsync(c, currentJsonToInvoke, HttpMethod.Put, token).ConfigureAwait(false);
                }
            };

            async Task recursive()
            {
                try
                {
                    await invoke(jsonData).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    var retryEx = new RetryExceptionEventArgs(ex, Task.Run(async delegate
                    {
                        await Task.Delay(App.Config.DatabaseRetryDelay).ConfigureAwait(false);
                        return(false);
                    }));
                    onException?.Invoke(retryEx);
                    if (retryEx.Retry != null)
                    {
                        if (await retryEx.Retry)
                        {
                            await recursive().ConfigureAwait(false);
                        }
                    }
                }
            }

            await recursive().ConfigureAwait(false);
        }
Ejemplo n.º 2
0
        /// <inheritdoc/>
        public async Task <string> Get(CancellationToken?token = null, Action <RetryExceptionEventArgs> onException = null)
        {
            async Task <string> invoke()
            {
                var url          = string.Empty;
                var responseData = string.Empty;
                var statusCode   = HttpStatusCode.OK;

                if (App.Config.OfflineMode)
                {
                    throw new FirebaseException(FirebaseExceptionReason.OfflineMode, new Exception("Offline mode"));
                }

                try
                {
                    url = await BuildUrl(token).ConfigureAwait(false);

                    CancellationToken invokeToken;

                    if (token == null)
                    {
                        invokeToken = new CancellationTokenSource(App.Config.DatabaseRequestTimeout).Token;
                    }
                    else
                    {
                        invokeToken = CancellationTokenSource.CreateLinkedTokenSource(token.Value, new CancellationTokenSource(App.Config.DatabaseRequestTimeout).Token).Token;
                    }

                    var response = await GetClient().GetAsync(url, invokeToken).ConfigureAwait(false);

                    statusCode   = response.StatusCode;
                    responseData = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

                    response.EnsureSuccessStatusCode();
                    response.Dispose();

                    return(responseData);
                }
                catch (OperationCanceledException ex)
                {
                    throw new FirebaseException(FirebaseExceptionReason.OperationCancelled, ex);
                }
                catch (FirebaseException ex)
                {
                    throw ex;
                }
                catch (Exception ex)
                {
                    throw new FirebaseException(ExceptionHelpers.GetFailureReason(statusCode), ex);
                }
            }

            async Task <string> recursive()
            {
                try
                {
                    return(await invoke().ConfigureAwait(false));
                }
                catch (Exception ex)
                {
                    var retryEx = new RetryExceptionEventArgs(ex, Task.Run(async delegate
                    {
                        await Task.Delay(App.Config.DatabaseRetryDelay).ConfigureAwait(false);
                        return(false);
                    }));
                    onException?.Invoke(retryEx);
                    if (retryEx.Retry != null)
                    {
                        if (await retryEx.Retry)
                        {
                            await recursive().ConfigureAwait(false);
                        }
                    }
                    return(null);
                }
            }

            return(await recursive().ConfigureAwait(false));
        }