def _url_query(self, api_call, retries=0): try: if self.debug: print("Query url: " + self.url + api_call) response = urllib.request.urlopen(self.url + api_call) if response.code == 200: return True return False # pragma: no cover except urllib.error.HTTPError as e: if e.code == 409: raise exceptions.AddressAlreadyRegistered( self.address, self.url) elif e.code == 404: raise exceptions.FarmerNotFound(self.url) elif e.code == 400: raise exceptions.InvalidAddress(self.address) elif e.code == 500: # pragma: no cover raise exceptions.FarmerError(self.url) # pragma: no cover else: raise e # pragma: no cover except HTTPException: self._handle_connection_error(api_call, retries) except urllib.error.URLError: self._handle_connection_error(api_call, retries) except socket.error: self._handle_connection_error(api_call, retries)
def __init__(self, url=common.DEFAULT_URL, debug=False, max_size=common.DEFAULT_MAX_SIZE, store_path=common.DEFAULT_STORE_PATH, config_path=common.DEFAULT_CONFIG_PATH, set_master_secret=None, set_payout_address=None, connection_retry_limit=common.DEFAULT_CONNECTION_RETRY_LIMIT, connection_retry_delay=common.DEFAULT_CONNECTION_RETRY_DELAY): # FIXME validate master_secret self.url = url self.config = None # lazy self.messanger = None # lazy self.debug = debug # TODO validate self.retry_limit = deserialize.positive_integer(connection_retry_limit) self.retry_delay = deserialize.positive_integer(connection_retry_delay) self.max_size = deserialize.byte_count(max_size) # paths self.config_path = os.path.realpath(config_path) # TODO validate self._ensure_path_exists(os.path.dirname(self.config_path)) self.store_path = os.path.realpath(store_path) self._ensure_path_exists(self.store_path) # validate payout address self.btctxstore = BtcTxStore() if set_payout_address and (not self.btctxstore.validate_address(set_payout_address)): raise exceptions.InvalidAddress(set_payout_address) self._initialize_config(set_master_secret, set_payout_address)
def _url_query(self, api_path, retries=0, authenticate=True): try: req = urllib.request.Request(self._server_url + api_path) if self._get_wif() and authenticate: headers = self._create_authentication_headers() req.add_header("Date", headers["Date"]) req.add_header("Authorization", headers["Authorization"]) response = urllib.request.urlopen(req) if response.code == 200: return response.read() except urllib.error.HTTPError as e: if e.code == 409: raise exceptions.AddressAlreadyRegistered( self.auth_address(), self._server_url) elif e.code == 404: raise exceptions.FarmerNotFound(self._server_url) elif e.code == 400: raise exceptions.InvalidAddress(self.auth_address()) elif e.code == 500: # pragma: no cover raise exceptions.FarmerError(self._server_url) else: raise e # pragma: no cover except http.client.HTTPException: self._handle_connection_error(api_path, retries, authenticate) except urllib.error.URLError: self._handle_connection_error(api_path, retries, authenticate) except socket.error: self._handle_connection_error(api_path, retries, authenticate)
def _url_query(self, api_call, retries=0): try: if self.debug: print("Query url: " + self.url + api_call) response = urllib.request.urlopen(self.url + api_call) if response.code == 200: return True return False # pragma: no cover except urllib.error.HTTPError as e: if e.code == 409: raise exceptions.AddressAlreadyRegistered(self.address, self.url) elif e.code == 404: raise exceptions.FarmerNotFound(self.url) elif e.code == 400: raise exceptions.InvalidAddress(self.address) elif e.code == 500: # pragma: no cover raise exceptions.FarmerError(self.url) # pragma: no cover else: raise e # pragma: no cover except urllib.error.URLError: if retries >= self.connection_retry_limit: raise exceptions.ConnectionError(self.url) time.sleep(self.connection_retry_delay) return self._url_query(api_call, retries + 1)
def register(self, payout_addr): """Attempt to register this client address.""" if payout_addr and not self.btctxstore.validate_address(payout_addr): logger.error("Invalid payout address '{0}'".format(payout_addr)) raise exceptions.InvalidAddress(payout_addr) if payout_addr: return self._url_query("/api/register/{0}/{1}".format( self.get_nodeid(), payout_addr))
def _get_server_address(self): if not self._server_address: data = self._url_query("/api/address", authenticate=False) self._server_address = json.loads(data.decode("utf-8"))["address"] if not self.btctxstore.validate_address(self._server_address): logger.error("Invalid server address '{0}'".format( self._server_address)) raise exceptions.InvalidAddress(self._server_address) return self._server_address
def register(self, payout_addr): """Attempt to register this client address.""" if payout_addr and not self._btctxstore.validate_address(payout_addr): raise exceptions.InvalidAddress(payout_addr) if payout_addr: return self._url_query("/api/register/{0}/{1}".format( self.auth_address(), payout_addr)) data = self._url_query("/api/register/{0}".format(self.auth_address())) data = json.loads(data.decode("utf-8")) payout_addr = payout_addr if payout_addr else self.auth_address() return (data["btc_addr"] == self.auth_address() and data["payout_addr"] == payout_addr)
def _url_query(self, api_path, authenticate=True): # NOQA i = 0 while i <= self.retry_limit: i += 1 try: query_url = self._server_url + api_path req = Request(query_url) starttime = datetime.utcnow() if self.wif and authenticate: headers = storjcore.auth.create_headers( self.btctxstore, self._get_server_address(), self.wif) req.add_header("Date", headers["Date"]) req.add_header("Authorization", headers["Authorization"]) logger.info("Query: {0} generated in {1}".format( query_url, datetime.utcnow() - starttime)) response = urlopen(req, timeout=30) if 200 <= response.code <= 299: return response.read() except HTTPError as e: if e.code == 409: raise exceptions.AddressAlreadyRegistered( self.get_nodeid(), self._server_url) elif e.code == 404: raise exceptions.ServerNotFound(self._server_url + api_path) elif e.code == 400: raise exceptions.InvalidAddress(self.get_nodeid()) elif e.code == 401: # auth error (likely clock off) # log "HTTP Error 401: UNAUTHORIZED" logger.warning(logmessages.InvalidAuthenticationHeaders()) elif e.code == 500: # pragma: no cover raise exceptions.ServerError(self._server_url) else: raise e # pragma: no cover except http.client.HTTPException as e: logger.warning(repr(e)) except URLError as e: logger.warning(repr(e)) except socket.error as e: logger.warning(repr(e)) # retry delay = self.retry_delay logger.info("Query retry in {0} seconds.".format(delay)) time.sleep(delay) # retry limit logger.error("Failed to connect to {0}".format(self._server_url)) raise exceptions.ConnectionError(self._server_url)
def config(self, set_wallet=None, set_payout_address=None): """ Set and then show the config settings. :param set_wallet: Set the HWIF for registration/auth address. :param set_payout_address: Set the payout address. :return: Configuation object. """ if((set_payout_address is not None) and (not self.btctxstore.validate_address(set_payout_address))): raise exceptions.InvalidAddress(set_payout_address) if((set_wallet is not None) and (not self.btctxstore.validate_wallet(set_wallet))): raise exceptions.InvalidHWIF(set_wallet) self._init_messenger() config_updated = False # update payout address if requested if set_payout_address: self.cfg["payout_address"] = set_payout_address config_updated = True # update wallet if requested if set_wallet: self.cfg["wallet"] = set_wallet config_updated = True # save config if updated if config_updated: control.config.save(self.btctxstore, self.cfg_path, self.cfg) # display config print(SHOW_CONFIG_TEMPLATE.format( self.messenger.auth_address(), self.cfg["payout_address"] )) return self.cfg
def _url_query(self, api_path, retries=0, authenticate=True): try: query_url = self._server_url + api_path req = urllib.request.Request(query_url) if self.wif and authenticate: headers = storjcore.auth.create_headers( self.btctxstore, self._get_server_address(), self.wif) req.add_header("Date", headers["Date"]) req.add_header("Authorization", headers["Authorization"]) logger.info("Query: {0}".format(query_url)) response = urllib.request.urlopen(req) if response.code == 200: return response.read() except urllib.error.HTTPError as e: logger.warning(repr(e)) if e.code == 409: raise exceptions.AddressAlreadyRegistered( self.auth_address(), self._server_url) elif e.code == 404: raise exceptions.ServerNotFound(self._server_url) elif e.code == 400: raise exceptions.InvalidAddress(self.auth_address()) elif e.code == 401: # auth error (likely clock off) logger.warning(repr(e)) self._handle_connection_error(api_path, retries, authenticate) elif e.code == 500: # pragma: no cover raise exceptions.ServerError(self._server_url) else: raise e # pragma: no cover except http.client.HTTPException as e: logger.warning(repr(e)) self._handle_connection_error(api_path, retries, authenticate) except urllib.error.URLError as e: logger.warning(repr(e)) self._handle_connection_error(api_path, retries, authenticate) except socket.error as e: logger.warning(repr(e)) self._handle_connection_error(api_path, retries, authenticate)