[NBA-39] add multiple nodes for web3 HTTPProvider

web3/providers/rpc.py

@@ -1,4 +1,14 @@
+from eth_typing import (
+    URI,
+)
+from eth_utils import (
+    to_dict,
+)
 import logging
+import random
+from requests import (
+    RequestException,
+)
 from typing import (
     Any,
     Dict,
@@ -8,13 +18,6 @@
     Union,
 )
 
-from eth_typing import (
-    URI,
-)
-from eth_utils import (
-    to_dict,
-)
-
 from web3._utils.http import (
     construct_user_agent,
 )
@@ -26,9 +29,15 @@
 from web3.datastructures import (
     NamedElementOnion,
 )
+from web3.exceptions import (
+    CannotHandleRequest,
+)
 from web3.middleware import (
     http_retry_request_middleware,
 )
+from web3.providers import (
+    BaseProvider,
+)
 from web3.types import (
     Middleware,
     RPCEndpoint,
@@ -42,56 +51,70 @@
 
 class HTTPProvider(JSONBaseProvider):
     logger = logging.getLogger("web3.providers.HTTPProvider")
-    endpoint_uri = None
+    providers = None
     _request_args = None
     _request_kwargs = None
     # type ignored b/c conflict with _middlewares attr on BaseProvider
-    _middlewares: Tuple[Middleware, ...] = NamedElementOnion([(http_retry_request_middleware, 'http_retry_request')])  # type: ignore # noqa: E501
+    _middlewares: Tuple[Middleware, ...] = NamedElementOnion([(http_retry_request_middleware, "http_retry_request")])  # type: ignore # noqa: E501
 
     def __init__(
-        self, endpoint_uri: Optional[Union[URI, str]] = None,
-            request_kwargs: Optional[Any] = None,
-            session: Optional[Any] = None
+        self,
+        providers: Union[list, str],
+        randomize: Optional[bool] = False,
+        request_kwargs: Optional[Any] = None,
+        session: Optional[Any] = None,
     ) -> None:
-        if endpoint_uri is None:
-            self.endpoint_uri = get_default_http_endpoint()
-        else:
-            self.endpoint_uri = URI(endpoint_uri)
-
+        if isinstance(providers, str):
+            providers = [
+                providers,
+            ]
+        self.randomize = randomize
+        self.providers = providers
         self._request_kwargs = request_kwargs or {}
 
         if session:
-            cache_session(self.endpoint_uri, session)
+            cache_session(self.providers[0], session)
 
         super().__init__()
 
     def __str__(self) -> str:
-        return "RPC connection {0}".format(self.endpoint_uri)
+        return "RPC connection {0}".format(self.providers)
 
     @to_dict
     def get_request_kwargs(self) -> Iterable[Tuple[str, Any]]:
-        if 'headers' not in self._request_kwargs:
-            yield 'headers', self.get_request_headers()
+        if "headers" not in self._request_kwargs:
+            yield "headers", self.get_request_headers()
         for key, value in self._request_kwargs.items():
             yield key, value
 
     def get_request_headers(self) -> Dict[str, str]:
         return {
-            'Content-Type': 'application/json',
-            'User-Agent': construct_user_agent(str(type(self))),
+            "Content-Type": "application/json",
+            "User-Agent": construct_user_agent(str(type(self))),
         }
 
     def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        self.logger.debug("Making request HTTP. URI: %s, Method: %s",
-                          self.endpoint_uri, method)
         request_data = self.encode_rpc_request(method, params)
-        raw_response = make_post_request(
-            self.endpoint_uri,
-            request_data,
-            **self.get_request_kwargs()
-        )
-        response = self.decode_rpc_response(raw_response)
-        self.logger.debug("Getting response HTTP. URI: %s, "
-                          "Method: %s, Response: %s",
-                          self.endpoint_uri, method, response)
-        return response
+        if self.randomize:
+            random.shuffle(self.providers)
+        for provider in self.providers:
+            provider_uri = URI(provider)
+            self.logger.debug(
+                "Making request HTTP. URI: %s, Method: %s", provider_uri, method
+            )
+            try:
+                raw_response = make_post_request(
+                    provider_uri, request_data, **self.get_request_kwargs()
+                )
+                response = self.decode_rpc_response(raw_response)
+                self.logger.debug(
+                    "Getting response HTTP. URI: %s, " "Method: %s, Response: %s",
+                    provider_uri,
+                    method,
+                    response,
+                )
+                return response
+            except RequestException:
+                pass
+        else:
+            raise CannotHandleRequest