def __init__(self, web3, providers, middlewares=None): self.web3 = web3 self.pending_requests = {} if middlewares is None: middlewares = [attrdict_middleware, pythonic_middleware] self.middleware_stack = NamedElementStack(middlewares) self.providers = providers
def __init__(self, web3, providers, middlewares=None): self.web3 = web3 self.pending_requests = {} if middlewares is None: middlewares = self.default_middlewares(web3) self.middleware_stack = NamedElementStack(middlewares) self.providers = providers
class HTTPProvider(JSONBaseProvider): endpoint_uri = None _request_args = None _request_kwargs = None _middlewares = NamedElementStack([(http_retry_request_middleware, 'http_retry_request')]) def __init__(self, endpoint_uri=None, request_kwargs=None): if endpoint_uri is None: self.endpoint_uri = get_default_endpoint() else: self.endpoint_uri = endpoint_uri self._request_kwargs = request_kwargs or {} super().__init__() def __str__(self): return "RPC connection {0}".format(self.endpoint_uri) @to_dict def get_request_kwargs(self): 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): return { 'Content-Type': 'application/json', 'User-Agent': construct_user_agent(str(type(self))), } def make_request(self, method, params): 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) return response
class RequestManager(object): def __init__(self, web3, providers, middlewares=None): self.web3 = web3 self.pending_requests = {} if middlewares is None: middlewares = [attrdict_middleware, pythonic_middleware] self.middleware_stack = NamedElementStack(middlewares) self.providers = providers web3 = None _providers = None @deprecated_for("manager.middleware_stack.add(middleware [, name])") def add_middleware(self, middleware): return self.middleware_stack.add(middleware) @deprecated_for("manager.middleware_stack.clear()") def clear_middlewares(self): return self.middleware_stack.clear() @property def providers(self): return self._providers or tuple() @providers.setter def providers(self, value): if not is_list_like(value): providers = [value] else: providers = value self._providers = providers def setProvider(self, providers): warnings.warn( DeprecationWarning( "The `setProvider` API has been deprecated. You should update your " "code to directly set the `manager.provider` property.")) self.providers = providers # # Provider requests and response # def _make_request(self, method, params): for provider in self.providers: request_func = provider.request_func(self.web3, tuple(self.middleware_stack)) try: return request_func(method, params) except CannotHandleRequest: continue else: raise UnhandledRequest( "No providers responded to the RPC request:\n" "method:{0}\n" "params:{1}\n".format( method, params, )) def request_blocking(self, method, params): """ Make a synchronous request using the provider """ response = self._make_request(method, params) if "error" in response: raise ValueError(response["error"]) return response['result'] def request_async(self, raw_method, raw_params): request_id = uuid.uuid4() self.pending_requests[request_id] = spawn( self.request_blocking, raw_method=raw_method, raw_params=raw_params, ) return request_id def receive_blocking(self, request_id, timeout=None): try: request = self.pending_requests.pop(request_id) except KeyError: raise KeyError("Request for id:{0} not found".format(request_id)) else: response = request.get(timeout=timeout) if "error" in response: raise ValueError(response["error"]) return response['result'] def receive_async(self, request_id, *args, **kwargs): raise NotImplementedError("Callback pattern not implemented")