Error handling revamp - A prototype

Author: hiranya911

src/main/java/com/google/firebase/ErrorCode.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase;
+
+public enum ErrorCode {
+
+  INVALID_ARGUMENT,
+
+  FAILED_PRECONDITION,
+
+  OUT_OF_RANGE,
+
+  UNAUTHENTICATED,
+
+  PERMISSION_DENIED,
+
+  NOT_FOUND,
+
+  CONFLICT,
+
+  ABORTED,
+
+  ALREADY_EXISTS,
+
+  RESOURCE_EXHAUSTED,
+
+  CANCELLED,
+
+  DATA_LOSS,
+
+  UNKNOWN,
+
+  INTERNAL,
+
+  UNAVAILABLE,
+
+  DEADLINE_EXCEEDED,
+}

src/main/java/com/google/firebase/FirebaseException.java

@@ -17,24 +17,42 @@
 package com.google.firebase;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.base.Strings;
 import com.google.firebase.internal.NonNull;
+import com.google.firebase.internal.Nullable;
 
 /** Base class for all Firebase exceptions. */
 public class FirebaseException extends Exception {
 
-  // TODO(b/27677218): Exceptions should have non-empty messages.
-  @Deprecated
-  protected FirebaseException() {}
+  private final ErrorCode errorCode;
+  private final FirebaseHttpResponse response;
 
   public FirebaseException(@NonNull String detailMessage) {
-    super(detailMessage);
-    checkArgument(!Strings.isNullOrEmpty(detailMessage), "Detail message must not be empty");
+    this(detailMessage, null);
   }
 
   public FirebaseException(@NonNull String detailMessage, Throwable cause) {
-    super(detailMessage, cause);
-    checkArgument(!Strings.isNullOrEmpty(detailMessage), "Detail message must not be empty");
+    this(ErrorCode.UNKNOWN, detailMessage, null, cause);
+  }
+
+  public FirebaseException(
+      @NonNull ErrorCode errorCode,
+      @NonNull String message,
+      @Nullable FirebaseHttpResponse response,
+      @Nullable Throwable cause) {
+    super(message, cause);
+    checkArgument(!Strings.isNullOrEmpty(message), "Message must not be null or empty");
+    this.errorCode = checkNotNull(errorCode);
+    this.response = response;
+  }
+
+  public ErrorCode getPlatformErrorCode() {
+    return errorCode;
+  }
+
+  @Nullable public FirebaseHttpResponse getHttpResponse() {
+    return response;
   }
 }

src/main/java/com/google/firebase/FirebaseHttpResponse.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase;
+
+import com.google.api.client.http.HttpRequest;
+import com.google.api.client.http.HttpResponse;
+import com.google.api.client.http.HttpResponseException;
+import com.google.common.collect.ImmutableMap;
+import java.util.Map;
+
+public final class FirebaseHttpResponse {
+
+  private final int statusCode;
+  private final String content;
+  private final Map<String, Object> headers;
+  private final HttpRequest request;
+
+  public FirebaseHttpResponse(HttpResponse response, String content) {
+    this.statusCode = response.getStatusCode();
+    this.content = content;
+    this.headers = ImmutableMap.copyOf(response.getHeaders());
+    this.request = response.getRequest();
+  }
+
+  public FirebaseHttpResponse(HttpResponseException e, HttpRequest request) {
+    this.statusCode = e.getStatusCode();
+    this.content = e.getContent();
+    this.headers = ImmutableMap.copyOf(e.getHeaders());
+    this.request = request;
+  }
+
+  public int getStatusCode() {
+    return this.statusCode;
+  }
+
+  public String getContent() {
+    return this.content;
+  }
+
+  public Map<String, Object> getHeaders() {
+    return this.headers;
+  }
+
+  public HttpRequest getRequest() {
+    return request;
+  }
+}

src/main/java/com/google/firebase/internal/ApiClientUtils.java

@@ -20,9 +20,18 @@
 import com.google.api.client.http.HttpResponse;
 import com.google.api.client.http.HttpTransport;
 import com.google.common.collect.ImmutableList;
+import com.google.firebase.ErrorCode;
 import com.google.firebase.FirebaseApp;
 
+import com.google.firebase.FirebaseException;
 import java.io.IOException;
+import java.net.ConnectException;
+import java.net.NoRouteToHostException;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  * A set of shared utilities for using the Google API client.
@@ -43,9 +52,22 @@ public class ApiClientUtils {
    * @return A new {@code HttpRequestFactory} instance.
    */
   public static HttpRequestFactory newAuthorizedRequestFactory(FirebaseApp app) {
+    return newAuthorizedRequestFactory(app, DEFAULT_RETRY_CONFIG);
+  }
+
+  /**
+   * Creates a new {@code HttpRequestFactory} which provides authorization (OAuth2), timeouts and
+   * automatic retries.
+   *
+   * @param app {@link FirebaseApp} from which to obtain authorization credentials.
+   * @param retryConfig {@link RetryConfig} which specifies how and when to retry errors.
+   * @return A new {@code HttpRequestFactory} instance.
+   */
+  public static HttpRequestFactory newAuthorizedRequestFactory(
+      FirebaseApp app, @Nullable RetryConfig retryConfig) {
     HttpTransport transport = app.getOptions().getHttpTransport();
     return transport.createRequestFactory(
-        new FirebaseRequestInitializer(app, DEFAULT_RETRY_CONFIG));
+        new FirebaseRequestInitializer(app, retryConfig));
   }
 
   public static HttpRequestFactory newUnauthorizedRequestFactory(FirebaseApp app) {
@@ -62,4 +84,38 @@ public static void disconnectQuietly(HttpResponse response) {
       }
     }
   }
+
+  public static FirebaseException newFirebaseException(IOException e) {
+    ErrorCode code = ErrorCode.UNKNOWN;
+    String message = "Unknown error while making a remote service call" ;
+    if (isInstance(e, SocketTimeoutException.class)) {
+      code = ErrorCode.DEADLINE_EXCEEDED;
+      message = "Timed out while making an API call";
+    }
+
+    if (isInstance(e, UnknownHostException.class) || isInstance(e, NoRouteToHostException.class)) {
+      code = ErrorCode.UNAVAILABLE;
+      message = "Failed to establish a connection";
+    }
+
+    return new FirebaseException(code, message + ": " + e.getMessage(), null, e);
+  }
+
+  private static <T> boolean isInstance(IOException t, Class<T> type) {
+    Throwable current = t;
+    Set<Throwable> chain = new HashSet<>();
+    while (current != null) {
+      if (!chain.add(current)) {
+        break;
+      }
+
+      if (type.isInstance(current)) {
+        return true;
+      }
+
+      current = current.getCause();
+    }
+
+    return false;
+  }
 }

src/main/java/com/google/firebase/internal/BaseHttpErrorHandler.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.internal;
+
+import com.google.api.client.http.HttpResponseException;
+import com.google.api.client.http.HttpStatusCodes;
+import com.google.common.collect.ImmutableMap;
+import com.google.firebase.ErrorCode;
+import com.google.firebase.FirebaseException;
+import com.google.firebase.FirebaseHttpResponse;
+import java.util.Map;
+
+public abstract class BaseHttpErrorHandler<T extends FirebaseException>
+    implements HttpErrorHandler<T> {
+
+  private static final Map<Integer, ErrorCode> HTTP_ERROR_CODES =
+      ImmutableMap.<Integer, ErrorCode>builder()
+          .put(HttpStatusCodes.STATUS_CODE_BAD_REQUEST, ErrorCode.INVALID_ARGUMENT)
+          .put(HttpStatusCodes.STATUS_CODE_UNAUTHORIZED, ErrorCode.UNAUTHENTICATED)
+          .put(HttpStatusCodes.STATUS_CODE_FORBIDDEN, ErrorCode.PERMISSION_DENIED)
+          .put(HttpStatusCodes.STATUS_CODE_NOT_FOUND, ErrorCode.NOT_FOUND)
+          .put(HttpStatusCodes.STATUS_CODE_CONFLICT, ErrorCode.CONFLICT)
+          .put(429, ErrorCode.RESOURCE_EXHAUSTED)
+          .put(HttpStatusCodes.STATUS_CODE_SERVER_ERROR, ErrorCode.INTERNAL)
+          .put(HttpStatusCodes.STATUS_CODE_SERVICE_UNAVAILABLE, ErrorCode.UNAVAILABLE)
+          .build();
+
+  @Override
+  public final T handleHttpResponseException(
+      HttpResponseException e, FirebaseHttpResponse response) {
+    ErrorParams params = this.getErrorParams(e, response);
+    return this.createException(params);
+  }
+
+  protected ErrorParams getErrorParams(HttpResponseException e, FirebaseHttpResponse response) {
+    ErrorCode code = HTTP_ERROR_CODES.get(e.getStatusCode());
+    if (code == null) {
+      code = ErrorCode.UNKNOWN;
+    }
+
+    String message = String.format("Unexpected HTTP response with status: %d\n%s",
+        e.getStatusCode(), e.getContent());
+    return new ErrorParams(code, message, e, response);
+  }
+
+  protected abstract T createException(ErrorParams params);
+
+  public static final class ErrorParams {
+    private final ErrorCode errorCode;
+    private final String message;
+    private final HttpResponseException exception;
+    private final FirebaseHttpResponse response;
+
+    public ErrorParams(
+        ErrorCode errorCode, String message,
+        HttpResponseException e, FirebaseHttpResponse response) {
+      this.errorCode = errorCode;
+      this.message = message;
+      this.exception = e;
+      this.response = response;
+    }
+
+    public ErrorCode getErrorCode() {
+      return errorCode;
+    }
+
+    public String getMessage() {
+      return message;
+    }
+
+    public HttpResponseException getException() {
+      return exception;
+    }
+
+    public FirebaseHttpResponse getResponse() {
+      return response;
+    }
+  }
+}